Subversion Repositories openrisc

/*

FUNCTION

<<vprintf>>, <<vfprintf>>, <<vsprintf>>---format argument list

INDEX

        vprintf

INDEX

        vfprintf

INDEX

        vsprintf

INDEX

        vsnprintf

ANSI_SYNOPSIS

        #include <stdio.h>

        #include <stdarg.h>

        int vprintf(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 vsnprintf(char *<[str]>, size_t <[size]>, const char *<[fmt]>, va_list <[list]>);

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

                        va_list <[list]>);

        int _vfprintf_r(void *<[reent]>, FILE *<[fp]>, const char *<[fmt]>,

                        va_list <[list]>);

        int _vsprintf_r(void *<[reent]>, char *<[str]>, const char *<[fmt]>,

                        va_list <[list]>);

        int _vsnprintf_r(void *<[reent]>, char *<[str]>, size_t <[size]>, const char *<[fmt]>,

                        va_list <[list]>);

TRAD_SYNOPSIS

        #include <stdio.h>

        #include <varargs.h>

        int vprintf( <[fmt]>, <[list]>)

        char *<[fmt]>;

        va_list <[list]>;

        int vfprintf(<[fp]>, <[fmt]>, <[list]>)

        FILE *<[fp]>;

        char *<[fmt]>;

        va_list <[list]>;

        int vsprintf(<[str]>, <[fmt]>, <[list]>)

        char *<[str]>;

        char *<[fmt]>;

        va_list <[list]>;

        int vsnprintf(<[str]>, <[size]>, <[fmt]>, <[list]>)

        char *<[str]>;

        size_t <[size]>;

        char *<[fmt]>;

        va_list <[list]>;

        int _vprintf_r(<[reent]>, <[fmt]>, <[list]>)

        char *<[reent]>;

        char *<[fmt]>;

        va_list <[list]>;

        int _vfprintf_r(<[reent]>, <[fp]>, <[fmt]>, <[list]>)

        char *<[reent]>;

        FILE *<[fp]>;

        char *<[fmt]>;

        va_list <[list]>;

        int _vsprintf_r(<[reent]>, <[str]>, <[fmt]>, <[list]>)

        char *<[reent]>;

        char *<[str]>;

        char *<[fmt]>;

        va_list <[list]>;

        int _vsnprintf_r(<[reent]>, <[str]>, <[size]>, <[fmt]>, <[list]>)

        char *<[reent]>;

        char *<[str]>;

        size_t <[size]>;

        char *<[fmt]>;

        va_list <[list]>;

DESCRIPTION

<<vprintf>>, <<vfprintf>>, <<vsprintf>> and <<vsnprintf>> are (respectively)

variants of <<printf>>, <<fprintf>>, <<sprintf>> and <<snprintf>>.  They differ

only in allowing their caller to pass the variable argument list as a

<<va_list>> object (initialized by <<va_start>>) rather than directly

accepting a variable number of arguments.

RETURNS

The return values are consistent with the corresponding functions:

<<vsprintf>> returns the number of bytes in the output string,

save that the concluding <<NULL>> is not counted.

<<vprintf>> and <<vfprintf>> return the number of characters transmitted.

If an error occurs, <<vprintf>> and <<vfprintf>> return <<EOF>>. No

error returns occur for <<vsprintf>>.

PORTABILITY

ANSI C requires all three functions.

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

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

*/

/*-

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

 * All rights reserved.

 *

 * This code is derived from software contributed to Berkeley by

 * Chris Torek.

 *

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

 * modification, are permitted provided that the following conditions

 * are met:

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

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

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

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

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

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

 *    must display the following acknowledgement:

 *      This product includes software developed by the University of

 *      California, Berkeley and 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

 *    without specific prior written permission.

 *

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

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

 * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE

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

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

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

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

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

 * 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

 * SUCH DAMAGE.

 */

#define INTEGER_ONLY

#define _HAVE_STDC_

#define _NOLONGLONG

#define u_long unsigned long

#define u_short unsigned short

#define u_int unsigned int

#define _uquad_t u_long

#define _POINTER_INT int

#define _CONST const

#define NULL 0

#include "common.h"

#include "support.h"

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

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

static char *rcsid = "$Id: cprintf.c,v 1.2 2002-04-19 11:08:25 markom Exp $";

#endif /* LIBC_SCCS and not lint */

/*

 * Actual printf innards.

 *

 * This code is large and complicated...

 */

#ifdef INTEGER_ONLY

#define VFPRINTF vfiprintf

#define _VFPRINTF_R _vfiprintf_r

#else

#define VFPRINTF vfprintf

#define _VFPRINTF_R _vfprintf_r

#define FLOATING_POINT

#endif

#define _NO_LONGLONG

#if defined WANT_PRINTF_LONG_LONG && defined __GNUC__

# undef _NO_LONGLONG

#endif

#include <stdarg.h>

#ifdef FLOATING_POINT

//#include <locale.h>

//#include <math.h>

//#include "floatio.h"

#define BUF             (MAXEXP+MAXFRACT+1)     /* + decimal point */

#define DEFPREC         6

static char *cvt _PARAMS((struct _reent *, double, int, int, char *, int *, int, int *));

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

#else /* no FLOATING_POINT */

#define BUF             40

#endif /* FLOATING_POINT */

/*

 * Macros for converting digits to letters and vice versa

 */

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

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

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

/*

 * Flags used during conversion.

 */

#define ALT             0x001           /* alternate form */

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

#define LADJUST         0x004           /* left adjustment */

#define LONGDBL         0x008           /* long double; unimplemented */

#define LONGINT         0x010           /* long integer */

#define QUADINT         0x020           /* quad integer */

#define SHORTINT        0x040           /* short integer */

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

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

        /*

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

         * fields occur frequently, increase PADSIZE and make the initialisers

         * below longer.

         */

#define PADSIZE 16              /* pad chunk size */

        static _CONST char blanks[PADSIZE] =

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

        static _CONST char zeroes[PADSIZE] =

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

inline void pc (_CONST char c) {

#ifdef OR1K

  putc (c);

#else

  printf ("%c", c);

#endif

}

        /*

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

         */

inline void     PRINT(_CONST char *ptr, int len) {

  int i;

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

          pc(*(ptr++));

}

inline void PAD(int howmany, _CONST char *with) {

  int n;

        if ((n = howmany) > 0) {

                while (n > PADSIZE) {

                        PRINT(with, PADSIZE);

                        n -= PADSIZE;

                }

                PRINT(with, n);

        }

}

int printf(const char *fmt0,    ...)

{

        register char *fmt;     /* format string */

        register int ch;        /* character from fmt */

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

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

        register int flags;     /* flags as above */

        int ret;                /* return value accumulator */

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

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

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

        va_list ap;

#ifdef FLOATING_POINT

        char *decimal_point = localeconv()->decimal_point;

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

        /*

         * Although it is natural to declare this double here, the

         * declaration causes gcc to save FP registers even when not

         * printing an FP number.  This results in surprising use

         * of FP registers to print integers or strings on at least the

         * PowerPC.  A more proper solution would be to move FP printing

         * to another file, but this does seem to work.

         */

#if 0

        double _double;         /* double precision arguments %[eEfgG] */

#else

                                /* double precision arguments %[eEfgG] */

        union { int i; double d; } _double_ = {0};

#define _double (_double_.d)

#endif

        int expt;               /* integer value of exponent */

        int expsize;            /* character count for expstr */

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

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

#endif

#ifndef _NO_LONGLONG

#define quad_t    long long

#define u_quad_t  unsigned long long

#endif

#ifndef _NO_LONGLONG

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

#else

        u_long _uquad;

#endif

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

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

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

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

        char *xdigs = (char *)0;         /* digits for [xX] conversion */

#define NIOV 8

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

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

#define FLUSH()

        /*

         * To extend shorts properly, we need both signed and unsigned

         * argument extraction methods.

         */

#ifndef _NO_LONGLONG

#define SARG() \

        (flags&QUADINT ? va_arg(ap, quad_t) : \

            flags&LONGINT ? va_arg(ap, long) : \

            flags&SHORTINT ? (long)(short)va_arg(ap, int) : \

            (long)va_arg(ap, int))

#define UARG() \

        (flags&QUADINT ? va_arg(ap, u_quad_t) : \

            flags&LONGINT ? va_arg(ap, u_long) : \

            flags&SHORTINT ? (u_long)(u_short)va_arg(ap, int) : \

            (u_long)va_arg(ap, u_int))

#else

#define SARG() \

        (flags&LONGINT ? va_arg(ap, long) : \

            flags&SHORTINT ? (long)(short)va_arg(ap, int) : \

            (long)va_arg(ap, int))

#define UARG() \

        (flags&LONGINT ? va_arg(ap, u_long) : \

            flags&SHORTINT ? (u_long)(u_short)va_arg(ap, int) : \

            (u_long)va_arg(ap, u_int))

#endif

  va_start (ap, fmt0);

        fmt = (char *)fmt0;

        ret = 0;

        /*

         * Scan the format for conversions (`%' character).

         */

        for (;;) {

          while (*fmt != 0 && *fmt != '%') {

            pc (*fmt);

      fmt++;

      ret++;

    }

                if (!*fmt)

                        goto done;

    fmt++; /* Skip % */

                flags = 0;

                dprec = 0;

                width = 0;

                prec = -1;

                sign = '\0';

rflag:          ch = *fmt++;

reswitch:       switch (ch) {

                case ' ':

                        /*

                         * ``If the space and + flags both appear, the space

                         * flag will be ignored.''

                         *      -- ANSI X3J11

                         */

                        if (!sign)

                                sign = ' ';

                        goto rflag;

                case '#':

                        flags |= ALT;

                        goto rflag;

                case '*':

                        /*

                         * ``A negative field width argument is taken as a

                         * - flag followed by a positive field width.''

                         *      -- ANSI X3J11

                         * They don't exclude field widths read from args.

                         */

                        if ((width = va_arg(ap, int)) >= 0)

                                goto rflag;

                        width = -width;

                        /* FALLTHROUGH */

                case '-':

                        flags |= LADJUST;

                        goto rflag;

                case '+':

                        sign = '+';

                        goto rflag;

                case '.':

                        if ((ch = *fmt++) == '*') {

                                n = va_arg(ap, int);

                                prec = n < 0 ? -1 : n;

                                goto rflag;

                        }

                        n = 0;

                        while (is_digit(ch)) {

                                n = 10 * n + to_digit(ch);

                                ch = *fmt++;

                        }

                        prec = n < 0 ? -1 : n;

                        goto reswitch;

                case '0':

                        /*

                         * ``Note that 0 is taken as a flag, not as the

                         * beginning of a field width.''

                         *      -- ANSI X3J11

                         */

                        flags |= ZEROPAD;

                        goto rflag;

                case '1': case '2': case '3': case '4':

                case '5': case '6': case '7': case '8': case '9':

                        n = 0;

                        do {

                                n = 10 * n + to_digit(ch);

                                ch = *fmt++;

                        } while (is_digit(ch));

                        width = n;

                        goto reswitch;

#ifdef FLOATING_POINT

                case 'L':

                        flags |= LONGDBL;

                        goto rflag;

#endif

                case 'h':

                        flags |= SHORTINT;

                        goto rflag;

                case 'l':

                        if (*fmt == 'l') {

                                fmt++;

                                flags |= QUADINT;

                        } else {

                                flags |= LONGINT;

                        }

                        goto rflag;

                case 'q':

                        flags |= QUADINT;

                        goto rflag;

                case 'c':

                        *(cp = buf) = va_arg(ap, int);

                        size = 1;

                        sign = '\0';

                        break;

                case 'D':

                        flags |= LONGINT;

                        /*FALLTHROUGH*/

                case 'd':

                case 'i':

                        _uquad = SARG();

#ifndef _NO_LONGLONG

                        if ((quad_t)_uquad < 0)

#else

                        if ((long) _uquad < 0)

#endif

                        {

                                _uquad = -_uquad;

                                sign = '-';

                        }

                        base = DEC;

                        goto number;

#ifdef FLOATING_POINT

                case 'e':

                case 'E':

                case 'f':

                case 'g':

                case 'G':

                        if (prec == -1) {

                                prec = DEFPREC;

                        } else if ((ch == 'g' || ch == 'G') && prec == 0) {

                                prec = 1;

                        }

                        if (flags & LONGDBL) {

                                _double = (double) va_arg(ap, long double);

                        } else {

                                _double = va_arg(ap, double);

                        }

                        /* do this before tricky precision changes */

                        if (isinf(_double)) {

                                if (_double < 0)

                                        sign = '-';

                                cp = "Inf";

                                size = 3;

                                break;

                        }

                        if (isnan(_double)) {

                                cp = "NaN";

                                size = 3;

                                break;

                        }

                        flags |= FPT;

                        cp = cvt(data, _double, prec, flags, &softsign,

                                &expt, ch, &ndig);

                        if (ch == 'g' || ch == 'G') {

                                if (expt <= -4 || expt > prec)

                                        ch = (ch == 'g') ? 'e' : 'E';

                                else

                                        ch = 'g';

                        }

                        if (ch <= 'e') {        /* 'e' or 'E' fmt */

                                --expt;

                                expsize = exponent(expstr, expt, ch);

                                size = expsize + ndig;

                                if (ndig > 1 || flags & ALT)

                                        ++size;

                        } else if (ch == 'f') {         /* f fmt */

                                if (expt > 0) {

                                        size = expt;

                                        if (prec || flags & ALT)

                                                size += prec + 1;

                                } else  /* "0.X" */

                                        size = prec + 2;

                        } else if (expt >= ndig) {      /* fixed g fmt */

                                size = expt;

                                if (flags & ALT)

                                        ++size;

                        } else

                                size = ndig + (expt > 0 ?

                                        1 : 2 - expt);

                        if (softsign)

                                sign = '-';

                        break;

#endif /* FLOATING_POINT */

                case 'n':

#ifndef _NO_LONGLONG

                        if (flags & QUADINT)

                                *va_arg(ap, quad_t *) = ret;

                        else

#endif

                        if (flags & LONGINT)

                                *va_arg(ap, long *) = ret;

                        else if (flags & SHORTINT)

                                *va_arg(ap, short *) = ret;

                        else

                                *va_arg(ap, int *) = ret;

                        continue;       /* no output */

                case 'O':

                        flags |= LONGINT;

                        /*FALLTHROUGH*/

                case 'o':

                        _uquad = UARG();

                        base = OCT;

                        goto nosign;

                case 'p':

                        /*

                         * ``The argument shall be a pointer to void.  The

                         * value of the pointer is converted to a sequence

                         * of printable characters, in an implementation-

                         * defined manner.''

                         *      -- ANSI X3J11

                         */

                        /* NOSTRICT */

                        _uquad = (u_long)(unsigned _POINTER_INT)va_arg(ap, void *);

                        base = HEX;

                        xdigs = "0123456789abcdef";

                        flags |= HEXPREFIX;

                        ch = 'x';

                        goto nosign;

                case 's':

                        if ((cp = va_arg(ap, char *)) == NULL)

                                cp = "(null)";

                        if (prec >= 0) {

                                /*

                                 * can't use strlen; can only look for the

                                 * NUL in the first `prec' characters, and

                                 * strlen() will go further.

                                 */

                                char *p = (char *)memchr(cp, 0, prec);

                                if (p != NULL) {

                                        size = p - cp;

                                        if (size > prec)

                                                size = prec;

                                } else

                                        size = prec;

                        } else

                                size = strlen(cp);

                        sign = '\0';

                        break;

                case 'U':

                        flags |= LONGINT;

                        /*FALLTHROUGH*/

                case 'u':

                        _uquad = UARG();

                        base = DEC;

                        goto nosign;

                case 'X':

                        xdigs = "0123456789ABCDEF";

                        goto hex;

                case 'x':

                        xdigs = "0123456789abcdef";

hex:                    _uquad = UARG();

                        base = HEX;

                        /* leading 0x/X only if non-zero */

                        if (flags & ALT && _uquad != 0)

                                flags |= HEXPREFIX;

                        /* unsigned conversions */

nosign:                 sign = '\0';

                        /*

                         * ``... diouXx conversions ... if a precision is

                         * specified, the 0 flag will be ignored.''

                         *      -- ANSI X3J11

                         */

number:                 if ((dprec = prec) >= 0)

                                flags &= ~ZEROPAD;

                        /*

                         * ``The result of converting a zero value with an

                         * explicit precision of zero is no characters.''

                         *      -- ANSI X3J11

                         */

                        cp = buf + BUF;

                        if (_uquad != 0 || prec != 0) {

                                /*

                                 * Unsigned mod is hard, and unsigned mod

                                 * by a constant is easier than that by

                                 * a variable; hence this switch.

                                 */

                                switch (base) {

                                case OCT:

                                        do {

                                                *--cp = to_char(_uquad & 7);

                                                _uquad >>= 3;

                                        } while (_uquad);

                                        /* handle octal leading 0 */

                                        if (flags & ALT && *cp != '0')

                                                *--cp = '0';

                                        break;

                                case DEC:

                                        /* many numbers are 1 digit */

                                        while (_uquad >= 10) {

                                                *--cp = to_char(_uquad % 10);

                                                _uquad /= 10;

                                        }

                                        *--cp = to_char(_uquad);

                                        break;

                                case HEX:

                                        do {

                                                *--cp = xdigs[_uquad & 15];

                                                _uquad >>= 4;

                                        } while (_uquad);

                                        break;

                                default:

                                        cp = "bug in vfprintf: bad base";

                                        size = strlen(cp);

                                        goto skipsize;

                                }

                        }

                        size = buf + BUF - cp;

                skipsize:

                        break;

                default:        /* "%?" prints ?, unless ? is NUL */

                        if (ch == '\0')

                                goto done;

                        /* pretend it was %c with argument ch */

                        cp = buf;

                        *cp = ch;

                        size = 1;

                        sign = '\0';

                        break;

                }

                /*

                 * All reasonable formats wind up here.  At this point, `cp'

                 * points to a string which (if not flags&LADJUST) should be

                 * padded out to `width' places.  If flags&ZEROPAD, it should

                 * first be prefixed by any sign or other prefix; otherwise,

                 * it should be blank padded before the prefix is emitted.

                 * After any left-hand padding and prefixing, emit zeroes

                 * required by a decimal [diouxX] precision, then print the

                 * string proper, then emit zeroes required by any leftover

                 * floating precision; finally, if LADJUST, pad with blanks.

                 *

                 * Compute actual size, so we know how much to pad.

                 * size excludes decimal prec; realsz includes it.

                 */

                realsz = dprec > size ? dprec : size;

                if (sign)

                        realsz++;

                else if (flags & HEXPREFIX)

                        realsz+= 2;

                /* right-adjusting blank padding */

                if ((flags & (LADJUST|ZEROPAD)) == 0)

                        PAD(width - realsz, blanks);

                /* prefix */

                if (sign) {

                        PRINT(&sign, 1);

                } else if (flags & HEXPREFIX) {

                        ox[0] = '0';

                        ox[1] = ch;

                        PRINT(ox, 2);

                }

                /* right-adjusting zero padding */

                if ((flags & (LADJUST|ZEROPAD)) == ZEROPAD)

                        PAD(width - realsz, zeroes);