Subversion Repositories openrisc_2011-10-31

/*

/*

 * Copyright (c) 1990 The Regents of the University of California.

 * Copyright (c) 1990 The Regents of the University of California.

 * All rights reserved.

 * All rights reserved.

 *

 *

 * This code is derived from software contributed to Berkeley by

 * This code is derived from software contributed to Berkeley by

 * Chris Torek.

 * Chris Torek.

 *

 *

 * Redistribution and use in source and binary forms, with or without

 * Redistribution and use in source and binary forms, with or without

 * modification, are permitted provided that the following conditions

 * modification, are permitted provided that the following conditions

 * are met:

 * are met:

 * 1. Redistributions of source code must retain the above copyright

 * 1. Redistributions of source code must retain the above copyright

 *    notice, this list of conditions and the following disclaimer.

 *    notice, this list of conditions and the following disclaimer.

 * 2. Redistributions in binary form must reproduce the above copyright

 * 2. Redistributions in binary form must reproduce the above copyright

 *    notice, this list of conditions and the following disclaimer in the

 *    notice, this list of conditions and the following disclaimer in the

 *    documentation and/or other materials provided with the distribution.

 *    documentation and/or other materials provided with the distribution.

 * 3. All advertising materials mentioning features or use of this software

 * 3. All advertising materials mentioning features or use of this software

 *    must display the following acknowledgement:

 *    must display the following acknowledgement:

 *      This product includes software developed by the University of

 *      This product includes software developed by the University of

 *      California, Berkeley and its contributors.

 *      California, Berkeley and its contributors.

 * 4. Neither the name of the University nor the names of its contributors

 * 4. Neither the name of the University nor the names of its contributors

 *    may be used to endorse or promote products derived from this software

 *    may be used to endorse or promote products derived from this software

 *    without specific prior written permission.

 *    without specific prior written permission.

 *

 *

 * THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND

 * THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND

 * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE

 * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE

 * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE

 * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE

 * ARE DISCLAIMED.  IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE

 * ARE DISCLAIMED.  IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE

 * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL

 * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL

 * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS

 * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS

 * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)

 * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)

 * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT

 * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT

 * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY

 * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY

 * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF

 * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF

 * SUCH DAMAGE.

 * SUCH DAMAGE.

 */

 */

/*

/*

FUNCTION

FUNCTION

<<vfprintf>>, <<vprintf>>, <<vsprintf>>, <<vsnprintf>>, <<vasprintf>>, <<vasnprintf>>---format argument list

<<vfprintf>>, <<vprintf>>, <<vsprintf>>, <<vsnprintf>>, <<vasprintf>>, <<vasnprintf>>---format argument list

INDEX

INDEX

        vfprintf

        vfprintf

INDEX

INDEX

        _vfprintf_r

        _vfprintf_r

INDEX

INDEX

        vprintf

        vprintf

INDEX

INDEX

        _vprintf_r

        _vprintf_r

INDEX

INDEX

        vsprintf

        vsprintf

INDEX

INDEX

        _vsprintf_r

        _vsprintf_r

INDEX

INDEX

        vsnprintf

        vsnprintf

INDEX

INDEX

        _vsnprintf_r

        _vsnprintf_r

INDEX

INDEX

        vasprintf

        vasprintf

INDEX

INDEX

        _vasprintf_r

        _vasprintf_r

INDEX

INDEX

        vasnprintf

        vasnprintf

INDEX

INDEX

        _vasnprintf_r

        _vasnprintf_r

ANSI_SYNOPSIS

ANSI_SYNOPSIS

        #include <stdio.h>

        #include <stdio.h>

        #include <stdarg.h>

        #include <stdarg.h>

        int vprintf(const char *<[fmt]>, va_list <[list]>);

        int vprintf(const char *<[fmt]>, va_list <[list]>);

        int vfprintf(FILE *<[fp]>, const char *<[fmt]>, va_list <[list]>);

        int vfprintf(FILE *<[fp]>, const char *<[fmt]>, va_list <[list]>);

        int vsprintf(char *<[str]>, const char *<[fmt]>, va_list <[list]>);

        int vsprintf(char *<[str]>, const char *<[fmt]>, va_list <[list]>);

        int vsnprintf(char *<[str]>, size_t <[size]>, const char *<[fmt]>,

        int vsnprintf(char *<[str]>, size_t <[size]>, const char *<[fmt]>,

                      va_list <[list]>);

                      va_list <[list]>);

        int vasprintf(char **<[strp]>, const char *<[fmt]>, va_list <[list]>);

        int vasprintf(char **<[strp]>, const char *<[fmt]>, va_list <[list]>);

        char *vasnprintf(char *<[str]>, size_t *<[size]>, const char *<[fmt]>,

        char *vasnprintf(char *<[str]>, size_t *<[size]>, const char *<[fmt]>,

                         va_list <[list]>);

                         va_list <[list]>);

        int _vprintf_r(struct _reent *<[reent]>, const char *<[fmt]>,

        int _vprintf_r(struct _reent *<[reent]>, const char *<[fmt]>,

                        va_list <[list]>);

                        va_list <[list]>);

        int _vfprintf_r(struct _reent *<[reent]>, FILE *<[fp]>,

        int _vfprintf_r(struct _reent *<[reent]>, FILE *<[fp]>,

                        const char *<[fmt]>, va_list <[list]>);

                        const char *<[fmt]>, va_list <[list]>);

        int _vsprintf_r(struct _reent *<[reent]>, char *<[str]>,

        int _vsprintf_r(struct _reent *<[reent]>, char *<[str]>,

                        const char *<[fmt]>, va_list <[list]>);

                        const char *<[fmt]>, va_list <[list]>);

        int _vasprintf_r(struct _reent *<[reent]>, char **<[str]>,

        int _vasprintf_r(struct _reent *<[reent]>, char **<[str]>,

                         const char *<[fmt]>, va_list <[list]>);

                         const char *<[fmt]>, va_list <[list]>);

        int _vsnprintf_r(struct _reent *<[reent]>, char *<[str]>,

        int _vsnprintf_r(struct _reent *<[reent]>, char *<[str]>,

                         size_t <[size]>, const char *<[fmt]>, va_list <[list]>);

                         size_t <[size]>, const char *<[fmt]>, va_list <[list]>);

        char *_vasnprintf_r(struct _reent *<[reent]>, char *<[str]>,

        char *_vasnprintf_r(struct _reent *<[reent]>, char *<[str]>,

                            size_t *<[size]>, const char *<[fmt]>, va_list <[list]>);

                            size_t *<[size]>, const char *<[fmt]>, va_list <[list]>);

DESCRIPTION

DESCRIPTION

<<vprintf>>, <<vfprintf>>, <<vasprintf>>, <<vsprintf>>, <<vsnprintf>>,

<<vprintf>>, <<vfprintf>>, <<vasprintf>>, <<vsprintf>>, <<vsnprintf>>,

and <<vasnprintf>> are (respectively) variants of <<printf>>,

and <<vasnprintf>> are (respectively) variants of <<printf>>,

<<fprintf>>, <<asprintf>>, <<sprintf>>, <<snprintf>>, and

<<fprintf>>, <<asprintf>>, <<sprintf>>, <<snprintf>>, and

<<asnprintf>>.  They differ only in allowing their caller to pass the

<<asnprintf>>.  They differ only in allowing their caller to pass the

variable argument list as a <<va_list>> object (initialized by

variable argument list as a <<va_list>> object (initialized by

<<va_start>>) rather than directly accepting a variable number of

<<va_start>>) rather than directly accepting a variable number of

arguments.  The caller is responsible for calling <<va_end>>.

arguments.  The caller is responsible for calling <<va_end>>.

<<_vprintf_r>>, <<_vfprintf_r>>, <<_vasprintf_r>>, <<_vsprintf_r>>,

<<_vprintf_r>>, <<_vfprintf_r>>, <<_vasprintf_r>>, <<_vsprintf_r>>,

<<_vsnprintf_r>>, and <<_vasnprintf_r>> are reentrant versions of the

<<_vsnprintf_r>>, and <<_vasnprintf_r>> are reentrant versions of the

above.

above.

RETURNS

RETURNS

The return values are consistent with the corresponding functions.

The return values are consistent with the corresponding functions.

PORTABILITY

PORTABILITY

ANSI C requires <<vprintf>>, <<vfprintf>>, <<vsprintf>>, and

ANSI C requires <<vprintf>>, <<vfprintf>>, <<vsprintf>>, and

<<vsnprintf>>.  The remaining functions are newlib extensions.

<<vsnprintf>>.  The remaining functions are newlib extensions.

Supporting OS subroutines required: <<close>>, <<fstat>>, <<isatty>>,

Supporting OS subroutines required: <<close>>, <<fstat>>, <<isatty>>,

<<lseek>>, <<read>>, <<sbrk>>, <<write>>.

<<lseek>>, <<read>>, <<sbrk>>, <<write>>.

*/

*/

#if defined(LIBC_SCCS) && !defined(lint)

#if defined(LIBC_SCCS) && !defined(lint)

/*static char *sccsid = "from: @(#)vfprintf.c   5.50 (Berkeley) 12/16/92";*/

/*static char *sccsid = "from: @(#)vfprintf.c   5.50 (Berkeley) 12/16/92";*/

static char *rcsid = "$Id: vfprintf.c 207 2010-07-19 17:43:24Z jeremybennett $";

static char *rcsid = "$Id: vfprintf.c 207 2010-07-19 17:43:24Z jeremybennett $";

#endif /* LIBC_SCCS and not lint */

#endif /* LIBC_SCCS and not lint */

/*

/*

 * Actual printf innards.

 * Actual printf innards.

 *

 *

 * This code is large and complicated...

 * This code is large and complicated...

 */

 */

#include <newlib.h>

#include <newlib.h>

#ifdef INTEGER_ONLY

#ifdef INTEGER_ONLY

# define VFPRINTF vfiprintf

# define VFPRINTF vfiprintf

# ifdef STRING_ONLY

# ifdef STRING_ONLY

#   define _VFPRINTF_R _svfiprintf_r

#   define _VFPRINTF_R _svfiprintf_r

# else

# else

#   define _VFPRINTF_R _vfiprintf_r

#   define _VFPRINTF_R _vfiprintf_r

# endif

# endif

#else

#else

# define VFPRINTF vfprintf

# define VFPRINTF vfprintf

# ifdef STRING_ONLY

# ifdef STRING_ONLY

#   define _VFPRINTF_R _svfprintf_r

#   define _VFPRINTF_R _svfprintf_r

# else

# else

#   define _VFPRINTF_R _vfprintf_r

#   define _VFPRINTF_R _vfprintf_r

# endif

# endif

# ifndef NO_FLOATING_POINT

# ifndef NO_FLOATING_POINT

#  define FLOATING_POINT

#  define FLOATING_POINT

# endif

# endif

#endif

#endif

#define _NO_POS_ARGS

#define _NO_POS_ARGS

#ifdef _WANT_IO_POS_ARGS

#ifdef _WANT_IO_POS_ARGS

# undef _NO_POS_ARGS

# undef _NO_POS_ARGS

#endif

#endif

#include <_ansi.h>

#include <_ansi.h>

#include <reent.h>

#include <reent.h>

#include <stdio.h>

#include <stdio.h>

#include <stdlib.h>

#include <stdlib.h>

#include <string.h>

#include <string.h>

#include <limits.h>

#include <limits.h>

#include <stdint.h>

#include <stdint.h>

#include <wchar.h>

#include <wchar.h>

#include <sys/lock.h>

#include <sys/lock.h>

#include <stdarg.h>

#include <stdarg.h>

#include "local.h"

#include "local.h"

#include "../stdlib/local.h"

#include "../stdlib/local.h"

#include "fvwrite.h"

#include "fvwrite.h"

#include "vfieeefp.h"

#include "vfieeefp.h"

/* Currently a test is made to see if long double processing is warranted.

/* Currently a test is made to see if long double processing is warranted.

   This could be changed in the future should the _ldtoa_r code be

   This could be changed in the future should the _ldtoa_r code be

   preferred over _dtoa_r.  */

   preferred over _dtoa_r.  */

#define _NO_LONGDBL

#define _NO_LONGDBL

#if defined _WANT_IO_LONG_DOUBLE && (LDBL_MANT_DIG > DBL_MANT_DIG)

#if defined _WANT_IO_LONG_DOUBLE && (LDBL_MANT_DIG > DBL_MANT_DIG)

#undef _NO_LONGDBL

#undef _NO_LONGDBL

#endif

#endif

#define _NO_LONGLONG

#define _NO_LONGLONG

#if defined _WANT_IO_LONG_LONG \

#if defined _WANT_IO_LONG_LONG \

        && (defined __GNUC__ || __STDC_VERSION__ >= 199901L)

        && (defined __GNUC__ || __STDC_VERSION__ >= 199901L)

# undef _NO_LONGLONG

# undef _NO_LONGLONG

#endif

#endif

#ifdef STRING_ONLY

#ifdef STRING_ONLY

#define __SPRINT __ssprint_r

#define __SPRINT __ssprint_r

#else

#else

#define __SPRINT __sprint_r

#define __SPRINT __sprint_r

#endif

#endif

/* The __sprint_r/__ssprint_r functions are shared between all versions of

/* The __sprint_r/__ssprint_r functions are shared between all versions of

   vfprintf and vfwprintf.  They must only be defined once, which we do in

   vfprintf and vfwprintf.  They must only be defined once, which we do in

   the INTEGER_ONLY versions here. */

   the INTEGER_ONLY versions here. */

#ifdef STRING_ONLY

#ifdef STRING_ONLY

#ifdef INTEGER_ONLY

#ifdef INTEGER_ONLY

int

int

_DEFUN(__ssprint_r, (ptr, fp, uio),

_DEFUN(__ssprint_r, (ptr, fp, uio),

       struct _reent *ptr _AND

       struct _reent *ptr _AND

       FILE *fp _AND

       FILE *fp _AND

       register struct __suio *uio)

       register struct __suio *uio)

{

{

        register size_t len;

        register size_t len;

        register int w;

        register int w;

        register struct __siov *iov;

        register struct __siov *iov;

        register _CONST char *p = NULL;

        register _CONST char *p = NULL;

        iov = uio->uio_iov;

        iov = uio->uio_iov;

        len = 0;

        len = 0;

        if (uio->uio_resid == 0) {

        if (uio->uio_resid == 0) {

                uio->uio_iovcnt = 0;

                uio->uio_iovcnt = 0;

                return (0);

                return (0);

        }

        }

        do {

        do {

                while (len == 0) {

                while (len == 0) {

                        p = iov->iov_base;

                        p = iov->iov_base;

                        len = iov->iov_len;

                        len = iov->iov_len;

                        iov++;

                        iov++;

                }

                }

                w = fp->_w;

                w = fp->_w;

                if (len >= w && fp->_flags & (__SMBF | __SOPT)) {

                if (len >= w && fp->_flags & (__SMBF | __SOPT)) {

                        /* must be asprintf family */

                        /* must be asprintf family */

                        unsigned char *str;

                        unsigned char *str;

                        int curpos = (fp->_p - fp->_bf._base);

                        int curpos = (fp->_p - fp->_bf._base);

                        /* Choose a geometric growth factor to avoid

                        /* Choose a geometric growth factor to avoid

                         * quadratic realloc behavior, but use a rate less

                         * quadratic realloc behavior, but use a rate less

                         * than (1+sqrt(5))/2 to accomodate malloc

                         * than (1+sqrt(5))/2 to accomodate malloc

                         * overhead. asprintf EXPECTS us to overallocate, so

                         * overhead. asprintf EXPECTS us to overallocate, so

                         * that it can add a trailing \0 without

                         * that it can add a trailing \0 without

                         * reallocating.  The new allocation should thus be

                         * reallocating.  The new allocation should thus be

                         * max(prev_size*1.5, curpos+len+1). */

                         * max(prev_size*1.5, curpos+len+1). */

                        int newsize = fp->_bf._size * 3 / 2;

                        int newsize = fp->_bf._size * 3 / 2;

                        if (newsize < curpos + len + 1)

                        if (newsize < curpos + len + 1)

                                newsize = curpos + len + 1;

                                newsize = curpos + len + 1;

                        if (fp->_flags & __SOPT)

                        if (fp->_flags & __SOPT)

                        {

                        {

                                /* asnprintf leaves original buffer alone.  */

                                /* asnprintf leaves original buffer alone.  */

                                str = (unsigned char *)_malloc_r (ptr, newsize);

                                str = (unsigned char *)_malloc_r (ptr, newsize);

                                if (!str)

                                if (!str)

                                {

                                {

                                        ptr->_errno = ENOMEM;

                                        ptr->_errno = ENOMEM;

                                        goto err;

                                        goto err;

                                }

                                }

                                memcpy (str, fp->_bf._base, curpos);

                                memcpy (str, fp->_bf._base, curpos);

                                fp->_flags = (fp->_flags & ~__SOPT) | __SMBF;

                                fp->_flags = (fp->_flags & ~__SOPT) | __SMBF;

                        }

                        }

                        else

                        else

                        {

                        {

                                str = (unsigned char *)_realloc_r (ptr, fp->_bf._base,

                                str = (unsigned char *)_realloc_r (ptr, fp->_bf._base,

                                                newsize);

                                                newsize);

                                if (!str) {

                                if (!str) {

                                        /* Free unneeded buffer.  */

                                        /* Free unneeded buffer.  */

                                        _free_r (ptr, fp->_bf._base);

                                        _free_r (ptr, fp->_bf._base);

                                        /* Ensure correct errno, even if free

                                        /* Ensure correct errno, even if free

                                         * changed it.  */

                                         * changed it.  */

                                        ptr->_errno = ENOMEM;

                                        ptr->_errno = ENOMEM;

                                        goto err;

                                        goto err;

                                }

                                }

                        }

                        }

                        fp->_bf._base = str;

                        fp->_bf._base = str;

                        fp->_p = str + curpos;

                        fp->_p = str + curpos;

                        fp->_bf._size = newsize;

                        fp->_bf._size = newsize;

                        w = len;

                        w = len;

                        fp->_w = newsize - curpos;

                        fp->_w = newsize - curpos;

                }

                }

                if (len < w)

                if (len < w)

                        w = len;

                        w = len;

                (void)memmove ((_PTR) fp->_p, (_PTR) p, (size_t) (w));

                (void)memmove ((_PTR) fp->_p, (_PTR) p, (size_t) (w));

                fp->_w -= w;

                fp->_w -= w;

                fp->_p += w;

                fp->_p += w;

                w = len;          /* pretend we copied all */

                w = len;          /* pretend we copied all */

                p += w;

                p += w;

                len -= w;

                len -= w;

        } while ((uio->uio_resid -= w) != 0);

        } while ((uio->uio_resid -= w) != 0);

        uio->uio_resid = 0;

        uio->uio_resid = 0;

        uio->uio_iovcnt = 0;

        uio->uio_iovcnt = 0;

        return 0;

        return 0;

err:

err:

  fp->_flags |= __SERR;

  fp->_flags |= __SERR;

  uio->uio_resid = 0;

  uio->uio_resid = 0;

  uio->uio_iovcnt = 0;

  uio->uio_iovcnt = 0;

  return EOF;

  return EOF;

}

}

#else /* !INTEGER_ONLY */

#else /* !INTEGER_ONLY */

int __ssprint_r (struct _reent *, FILE *, register struct __suio *);

int __ssprint_r (struct _reent *, FILE *, register struct __suio *);

#endif /* !INTEGER_ONLY */

#endif /* !INTEGER_ONLY */

#else /* !STRING_ONLY */

#else /* !STRING_ONLY */

#ifdef INTEGER_ONLY

#ifdef INTEGER_ONLY

/*

/*

 * Flush out all the vectors defined by the given uio,

 * Flush out all the vectors defined by the given uio,

 * then reset it so that it can be reused.

 * then reset it so that it can be reused.

 */

 */

int

int

_DEFUN(__sprint_r, (ptr, fp, uio),

_DEFUN(__sprint_r, (ptr, fp, uio),

       struct _reent *ptr _AND

       struct _reent *ptr _AND

       FILE *fp _AND

       FILE *fp _AND

       register struct __suio *uio)

       register struct __suio *uio)

{

{

        register int err = 0;

        register int err = 0;

        if (uio->uio_resid == 0) {

        if (uio->uio_resid == 0) {

                uio->uio_iovcnt = 0;

                uio->uio_iovcnt = 0;

                return (0);

                return (0);

        }

        }

        if (fp->_flags2 & __SWID) {

        if (fp->_flags2 & __SWID) {

                struct __siov *iov;

                struct __siov *iov;

                wchar_t *p;

                wchar_t *p;

                int i, len;

                int i, len;

                iov = uio->uio_iov;

                iov = uio->uio_iov;

                for (; uio->uio_resid != 0;

                for (; uio->uio_resid != 0;

                     uio->uio_resid -= len * sizeof (wchar_t), iov++) {

                     uio->uio_resid -= len * sizeof (wchar_t), iov++) {

                        p = (wchar_t *) iov->iov_base;

                        p = (wchar_t *) iov->iov_base;

                        len = iov->iov_len / sizeof (wchar_t);

                        len = iov->iov_len / sizeof (wchar_t);

                        for (i = 0; i < len; i++) {

                        for (i = 0; i < len; i++) {

                                if (_fputwc_r (ptr, p[i], fp) == WEOF) {

                                if (_fputwc_r (ptr, p[i], fp) == WEOF) {

                                        err = -1;

                                        err = -1;

                                        goto out;

                                        goto out;

                                }

                                }

                        }

                        }

                }

                }

        } else

        } else

                err = __sfvwrite_r(ptr, fp, uio);

                err = __sfvwrite_r(ptr, fp, uio);

out:

out:

        uio->uio_resid = 0;

        uio->uio_resid = 0;

        uio->uio_iovcnt = 0;

        uio->uio_iovcnt = 0;

        return (err);

        return (err);

}

}

#else /* !INTEGER_ONLY */

#else /* !INTEGER_ONLY */

int __sprint_r (struct _reent *, FILE *, register struct __suio *);

int __sprint_r (struct _reent *, FILE *, register struct __suio *);

#endif /* !INTEGER_ONLY */

#endif /* !INTEGER_ONLY */

/*

/*

 * Helper function for `fprintf to unbuffered unix file': creates a

 * Helper function for `fprintf to unbuffered unix file': creates a

 * temporary buffer.  We only work on write-only files; this avoids

 * temporary buffer.  We only work on write-only files; this avoids

 * worries about ungetc buffers and so forth.

 * worries about ungetc buffers and so forth.

 */

 */

static int

static int

_DEFUN(__sbprintf, (rptr, fp, fmt, ap),

_DEFUN(__sbprintf, (rptr, fp, fmt, ap),

       struct _reent *rptr _AND

       struct _reent *rptr _AND

       register FILE *fp   _AND

       register FILE *fp   _AND

       _CONST char *fmt  _AND

       _CONST char *fmt  _AND

       va_list ap)

       va_list ap)

{

{

        int ret;

        int ret;

        FILE fake;

        FILE fake;

        unsigned char buf[BUFSIZ];

        unsigned char buf[BUFSIZ];

        /* copy the important variables */

        /* copy the important variables */

        fake._flags = fp->_flags & ~__SNBF;

        fake._flags = fp->_flags & ~__SNBF;

        fake._flags2 = fp->_flags2;

        fake._flags2 = fp->_flags2;

        fake._file = fp->_file;

        fake._file = fp->_file;

        fake._cookie = fp->_cookie;

        fake._cookie = fp->_cookie;

        fake._write = fp->_write;

        fake._write = fp->_write;

        /* set up the buffer */

        /* set up the buffer */

        fake._bf._base = fake._p = buf;

        fake._bf._base = fake._p = buf;

        fake._bf._size = fake._w = sizeof (buf);

        fake._bf._size = fake._w = sizeof (buf);

        fake._lbfsize = 0;       /* not actually used, but Just In Case */

        fake._lbfsize = 0;       /* not actually used, but Just In Case */

#ifndef __SINGLE_THREAD__

#ifndef __SINGLE_THREAD__

        __lock_init_recursive (fake._lock);

        __lock_init_recursive (fake._lock);

#endif

#endif

        /* do the work, then copy any error status */

        /* do the work, then copy any error status */

        ret = _VFPRINTF_R (rptr, &fake, fmt, ap);

        ret = _VFPRINTF_R (rptr, &fake, fmt, ap);

        if (ret >= 0 && _fflush_r (rptr, &fake))

        if (ret >= 0 && _fflush_r (rptr, &fake))

                ret = EOF;

                ret = EOF;

        if (fake._flags & __SERR)

        if (fake._flags & __SERR)

                fp->_flags |= __SERR;

                fp->_flags |= __SERR;

#ifndef __SINGLE_THREAD__

#ifndef __SINGLE_THREAD__

        __lock_close_recursive (fake._lock);

        __lock_close_recursive (fake._lock);

#endif

#endif

        return (ret);

        return (ret);

}

}

#endif /* !STRING_ONLY */

#endif /* !STRING_ONLY */

#ifdef FLOATING_POINT

#ifdef FLOATING_POINT

# include <locale.h>

# include <locale.h>

# include <math.h>

# include <math.h>

/* For %La, an exponent of 15 bits occupies the exponent character, a

/* For %La, an exponent of 15 bits occupies the exponent character, a

   sign, and up to 5 digits.  */

   sign, and up to 5 digits.  */

# define MAXEXPLEN              7

# define MAXEXPLEN              7

# define DEFPREC                6

# define DEFPREC                6

# ifdef _NO_LONGDBL

# ifdef _NO_LONGDBL

extern char *_dtoa_r _PARAMS((struct _reent *, double, int,

extern char *_dtoa_r _PARAMS((struct _reent *, double, int,

                              int, int *, int *, char **));

                              int, int *, int *, char **));

#  define _PRINTF_FLOAT_TYPE double

#  define _PRINTF_FLOAT_TYPE double

#  define _DTOA_R _dtoa_r

#  define _DTOA_R _dtoa_r

#  define FREXP frexp

#  define FREXP frexp

# else /* !_NO_LONGDBL */

# else /* !_NO_LONGDBL */

extern char *_ldtoa_r _PARAMS((struct _reent *, _LONG_DOUBLE, int,

extern char *_ldtoa_r _PARAMS((struct _reent *, _LONG_DOUBLE, int,

                              int, int *, int *, char **));

                              int, int *, int *, char **));

extern int _EXFUN(_ldcheck,(_LONG_DOUBLE *));

extern int _EXFUN(_ldcheck,(_LONG_DOUBLE *));

#  define _PRINTF_FLOAT_TYPE _LONG_DOUBLE

#  define _PRINTF_FLOAT_TYPE _LONG_DOUBLE

#  define _DTOA_R _ldtoa_r

#  define _DTOA_R _ldtoa_r

/* FIXME - frexpl is not yet supported; and cvt infloops if (double)f

/* FIXME - frexpl is not yet supported; and cvt infloops if (double)f

   converts a finite value into infinity.  */

   converts a finite value into infinity.  */

/* #  define FREXP frexpl */

/* #  define FREXP frexpl */

#  define FREXP(f,e) ((_LONG_DOUBLE) frexp ((double)f, e))

#  define FREXP(f,e) ((_LONG_DOUBLE) frexp ((double)f, e))

# endif /* !_NO_LONGDBL */

# endif /* !_NO_LONGDBL */

static char *cvt(struct _reent *, _PRINTF_FLOAT_TYPE, int, int, char *, int *,

static char *cvt(struct _reent *, _PRINTF_FLOAT_TYPE, int, int, char *, int *,

                 int, int *, char *);

                 int, int *, char *);

static int exponent(char *, int, int);

static int exponent(char *, int, int);

#endif /* FLOATING_POINT */

#endif /* FLOATING_POINT */

/* BUF must be big enough for the maximum %#llo (assuming long long is

/* BUF must be big enough for the maximum %#llo (assuming long long is

   at most 64 bits, this would be 23 characters), the maximum

   at most 64 bits, this would be 23 characters), the maximum

   multibyte character %C, and the maximum default precision of %La

   multibyte character %C, and the maximum default precision of %La

   (assuming long double is at most 128 bits with 113 bits of

   (assuming long double is at most 128 bits with 113 bits of

   mantissa, this would be 29 characters).  %e, %f, and %g use

   mantissa, this would be 29 characters).  %e, %f, and %g use

   reentrant storage shared with mprec.  All other formats that use

   reentrant storage shared with mprec.  All other formats that use

   buf get by with fewer characters.  Making BUF slightly bigger

   buf get by with fewer characters.  Making BUF slightly bigger

   reduces the need for malloc in %.*a and %S, when large precision or

   reduces the need for malloc in %.*a and %S, when large precision or

   long strings are processed.  */

   long strings are processed.  */

#define BUF             40

#define BUF             40

#if defined _MB_CAPABLE && MB_LEN_MAX > BUF

#if defined _MB_CAPABLE && MB_LEN_MAX > BUF

# undef BUF

# undef BUF

# define BUF MB_LEN_MAX

# define BUF MB_LEN_MAX

#endif

#endif

#ifndef _NO_LONGLONG

#ifndef _NO_LONGLONG

# define quad_t long long

# define quad_t long long

# define u_quad_t unsigned long long

# define u_quad_t unsigned long long

#else

#else

# define quad_t long

# define quad_t long

# define u_quad_t unsigned long

# define u_quad_t unsigned long

#endif

#endif

typedef quad_t * quad_ptr_t;

typedef quad_t * quad_ptr_t;

typedef _PTR     void_ptr_t;

typedef _PTR     void_ptr_t;

typedef char *   char_ptr_t;

typedef char *   char_ptr_t;

typedef long *   long_ptr_t;

typedef long *   long_ptr_t;

typedef int  *   int_ptr_t;

typedef int  *   int_ptr_t;

typedef short *  short_ptr_t;

typedef short *  short_ptr_t;

#ifndef _NO_POS_ARGS

#ifndef _NO_POS_ARGS

# ifdef NL_ARGMAX

# ifdef NL_ARGMAX

#  define MAX_POS_ARGS NL_ARGMAX

#  define MAX_POS_ARGS NL_ARGMAX

# else

# else

#  define MAX_POS_ARGS 32

#  define MAX_POS_ARGS 32

# endif

# endif

union arg_val

union arg_val

{

{

  int val_int;

  int val_int;

  u_int val_u_int;

  u_int val_u_int;

  long val_long;

  long val_long;

  u_long val_u_long;

  u_long val_u_long;

  float val_float;

  float val_float;

  double val_double;

  double val_double;

  _LONG_DOUBLE val__LONG_DOUBLE;

  _LONG_DOUBLE val__LONG_DOUBLE;

  int_ptr_t val_int_ptr_t;

  int_ptr_t val_int_ptr_t;

  short_ptr_t val_short_ptr_t;

  short_ptr_t val_short_ptr_t;

  long_ptr_t val_long_ptr_t;

  long_ptr_t val_long_ptr_t;

  char_ptr_t val_char_ptr_t;

  char_ptr_t val_char_ptr_t;

  quad_ptr_t val_quad_ptr_t;

  quad_ptr_t val_quad_ptr_t;

  void_ptr_t val_void_ptr_t;

  void_ptr_t val_void_ptr_t;

  quad_t val_quad_t;

  quad_t val_quad_t;

  u_quad_t val_u_quad_t;

  u_quad_t val_u_quad_t;

  wint_t val_wint_t;

  wint_t val_wint_t;

};

};

static union arg_val *

static union arg_val *

_EXFUN(get_arg, (struct _reent *data, int n, char *fmt,

_EXFUN(get_arg, (struct _reent *data, int n, char *fmt,

                 va_list *ap, int *numargs, union arg_val *args,

                 va_list *ap, int *numargs, union arg_val *args,

                 int *arg_type, char **last_fmt));

                 int *arg_type, char **last_fmt));

#endif /* !_NO_POS_ARGS */

#endif /* !_NO_POS_ARGS */

/*

/*

 * Macros for converting digits to letters and vice versa

 * Macros for converting digits to letters and vice versa

 */

 */

#define to_digit(c)     ((c) - '0')

#define to_digit(c)     ((c) - '0')

#define is_digit(c)     ((unsigned)to_digit (c) <= 9)

#define is_digit(c)     ((unsigned)to_digit (c) <= 9)

#define to_char(n)      ((n) + '0')

#define to_char(n)      ((n) + '0')

/*

/*

 * Flags used during conversion.

 * Flags used during conversion.

 */

 */

#define ALT             0x001           /* alternate form */

#define ALT             0x001           /* alternate form */

#define HEXPREFIX       0x002           /* add 0x or 0X prefix */

#define HEXPREFIX       0x002           /* add 0x or 0X prefix */

#define LADJUST         0x004           /* left adjustment */

#define LADJUST         0x004           /* left adjustment */

#define LONGDBL         0x008           /* long double */

#define LONGDBL         0x008           /* long double */

#define LONGINT         0x010           /* long integer */

#define LONGINT         0x010           /* long integer */

#ifndef _NO_LONGLONG

#ifndef _NO_LONGLONG

# define QUADINT        0x020           /* quad integer */

# define QUADINT        0x020           /* quad integer */

#else /* ifdef _NO_LONGLONG, make QUADINT equivalent to LONGINT, so

#else /* ifdef _NO_LONGLONG, make QUADINT equivalent to LONGINT, so

         that %lld behaves the same as %ld, not as %d, as expected if:

         that %lld behaves the same as %ld, not as %d, as expected if:

         sizeof (long long) = sizeof long > sizeof int  */

         sizeof (long long) = sizeof long > sizeof int  */

# define QUADINT        LONGINT

# define QUADINT        LONGINT

#endif

#endif

#define SHORTINT        0x040           /* short integer */

#define SHORTINT        0x040           /* short integer */

#define ZEROPAD         0x080           /* zero (as opposed to blank) pad */

#define ZEROPAD         0x080           /* zero (as opposed to blank) pad */

#define FPT             0x100           /* Floating point number */

#define FPT             0x100           /* Floating point number */

#ifdef _WANT_IO_C99_FORMATS

#ifdef _WANT_IO_C99_FORMATS

# define CHARINT        0x200           /* char as integer */

# define CHARINT        0x200           /* char as integer */

#else /* define as 0, to make SARG and UARG occupy fewer instructions  */

#else /* define as 0, to make SARG and UARG occupy fewer instructions  */

# define CHARINT        0

# define CHARINT        0

#endif

#endif

int _EXFUN(_VFPRINTF_R, (struct _reent *, FILE *, _CONST char *, va_list));

int _EXFUN(_VFPRINTF_R, (struct _reent *, FILE *, _CONST char *, va_list));

#ifndef STRING_ONLY

#ifndef STRING_ONLY

int

int

_DEFUN(VFPRINTF, (fp, fmt0, ap),

_DEFUN(VFPRINTF, (fp, fmt0, ap),

       FILE * fp         _AND

       FILE * fp         _AND

       _CONST char *fmt0 _AND

       _CONST char *fmt0 _AND

       va_list ap)

       va_list ap)

{

{

  int result;

  int result;

  result = _VFPRINTF_R (_REENT, fp, fmt0, ap);

  result = _VFPRINTF_R (_REENT, fp, fmt0, ap);

  return result;

  return result;

}

}

#endif /* STRING_ONLY */

#endif /* STRING_ONLY */

int

int

_DEFUN(_VFPRINTF_R, (data, fp, fmt0, ap),

_DEFUN(_VFPRINTF_R, (data, fp, fmt0, ap),

       struct _reent *data _AND

       struct _reent *data _AND

       FILE * fp           _AND

       FILE * fp           _AND

       _CONST char *fmt0   _AND

       _CONST char *fmt0   _AND

       va_list ap)

       va_list ap)

{

{

        register char *fmt;     /* format string */

        register char *fmt;     /* format string */

        register int ch;        /* character from fmt */

        register int ch;        /* character from fmt */

        register int n, m;      /* handy integers (short term usage) */

        register int n, m;      /* handy integers (short term usage) */

        register char *cp;      /* handy char pointer (short term usage) */

        register char *cp;      /* handy char pointer (short term usage) */

        register struct __siov *iovp;/* for PRINT macro */

        register struct __siov *iovp;/* for PRINT macro */

        register int flags;     /* flags as above */

        register int flags;     /* flags as above */

        char *fmt_anchor;       /* current format spec being processed */

        char *fmt_anchor;       /* current format spec being processed */

#ifndef _NO_POS_ARGS

#ifndef _NO_POS_ARGS

        int N;                  /* arg number */

        int N;                  /* arg number */

        int arg_index;          /* index into args processed directly */

        int arg_index;          /* index into args processed directly */

        int numargs;            /* number of varargs read */

        int numargs;            /* number of varargs read */

        char *saved_fmt;        /* saved fmt pointer */

        char *saved_fmt;        /* saved fmt pointer */

        union arg_val args[MAX_POS_ARGS];

        union arg_val args[MAX_POS_ARGS];

        int arg_type[MAX_POS_ARGS];

        int arg_type[MAX_POS_ARGS];

        int is_pos_arg;         /* is current format positional? */

        int is_pos_arg;         /* is current format positional? */

        int old_is_pos_arg;     /* is current format positional? */

        int old_is_pos_arg;     /* is current format positional? */

#endif

#endif

        int ret;                /* return value accumulator */

        int ret;                /* return value accumulator */

        int width;              /* width from format (%8d), or 0 */

        int width;              /* width from format (%8d), or 0 */

        int prec;               /* precision from format (%.3d), or -1 */

        int prec;               /* precision from format (%.3d), or -1 */

        char sign;              /* sign prefix (' ', '+', '-', or \0) */

        char sign;              /* sign prefix (' ', '+', '-', or \0) */

#ifdef FLOATING_POINT

#ifdef FLOATING_POINT

        char *decimal_point = _localeconv_r (data)->decimal_point;

        char *decimal_point = _localeconv_r (data)->decimal_point;

        size_t decp_len = strlen (decimal_point);

        size_t decp_len = strlen (decimal_point);

        char softsign;          /* temporary negative sign for floats */

        char softsign;          /* temporary negative sign for floats */

        union { int i; _PRINTF_FLOAT_TYPE fp; } _double_ = {0};

        union { int i; _PRINTF_FLOAT_TYPE fp; } _double_ = {0};

# define _fpvalue (_double_.fp)

# define _fpvalue (_double_.fp)

        int expt;               /* integer value of exponent */

        int expt;               /* integer value of exponent */

        int expsize = 0; /* character count for expstr */

        int expsize = 0; /* character count for expstr */

        int ndig = 0;            /* actual number of digits returned by cvt */

        int ndig = 0;            /* actual number of digits returned by cvt */

        char expstr[MAXEXPLEN]; /* buffer for exponent string */

        char expstr[MAXEXPLEN]; /* buffer for exponent string */

#endif /* FLOATING_POINT */

#endif /* FLOATING_POINT */

        u_quad_t _uquad;        /* integer arguments %[diouxX] */

        u_quad_t _uquad;        /* integer arguments %[diouxX] */

        enum { OCT, DEC, HEX } base;/* base for [diouxX] conversion */

        enum { OCT, DEC, HEX } base;/* base for [diouxX] conversion */

        int dprec;              /* a copy of prec if [diouxX], 0 otherwise */

        int dprec;              /* a copy of prec if [diouxX], 0 otherwise */

        int realsz;             /* field size expanded by dprec */

        int realsz;             /* field size expanded by dprec */

        int size;               /* size of converted field or string */

        int size;               /* size of converted field or string */

        char *xdigs = NULL;     /* digits for [xX] conversion */

        char *xdigs = NULL;     /* digits for [xX] conversion */

#define NIOV 8

#define NIOV 8

        struct __suio uio;      /* output information: summary */

        struct __suio uio;      /* output information: summary */

        struct __siov iov[NIOV];/* ... and individual io vectors */

        struct __siov iov[NIOV];/* ... and individual io vectors */

        char buf[BUF];          /* space for %c, %S, %[diouxX], %[aA] */

        char buf[BUF];          /* space for %c, %S, %[diouxX], %[aA] */

        char ox[2];             /* space for 0x hex-prefix */

        char ox[2];             /* space for 0x hex-prefix */

#ifdef _MB_CAPABLE

#ifdef _MB_CAPABLE

        wchar_t wc;

        wchar_t wc;

        mbstate_t state;        /* mbtowc calls from library must not change state */

        mbstate_t state;        /* mbtowc calls from library must not change state */

#endif

#endif

        char *malloc_buf = NULL;/* handy pointer for malloced buffers */

        char *malloc_buf = NULL;/* handy pointer for malloced buffers */

        /*

        /*

         * Choose PADSIZE to trade efficiency vs. size.  If larger printf

         * Choose PADSIZE to trade efficiency vs. size.  If larger printf

         * fields occur frequently, increase PADSIZE and make the initialisers

         * fields occur frequently, increase PADSIZE and make the initialisers

         * below longer.

         * below longer.

         */

         */

#define PADSIZE 16              /* pad chunk size */

#define PADSIZE 16              /* pad chunk size */

        static _CONST char blanks[PADSIZE] =

        static _CONST char blanks[PADSIZE] =

         {' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' '};

         {' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' '};

        static _CONST char zeroes[PADSIZE] =

        static _CONST char zeroes[PADSIZE] =

         {'0','0','0','0','0','0','0','0','0','0','0','0','0','0','0','0'};

         {'0','0','0','0','0','0','0','0','0','0','0','0','0','0','0','0'};

#ifdef _MB_CAPABLE

#ifdef _MB_CAPABLE

        memset (&state, '\0', sizeof (state));

        memset (&state, '\0', sizeof (state));

#endif

#endif

        /*

        /*

         * BEWARE, these `goto error' on error, and PAD uses `n'.

         * BEWARE, these `goto error' on error, and PAD uses `n'.

         */

         */

#define PRINT(ptr, len) { \