vfnprintf.cxx

eCos1.31版

//===========================================================================
//
//      vfnprintf.c
//
//      I/O routines for vfnprintf() for use with ANSI C library
//
//===========================================================================
//####COPYRIGHTBEGIN####
//                                                                          
// -------------------------------------------                              
// The contents of this file are subject to the Red Hat eCos Public License 
// Version 1.1 (the "License"); you may not use this file except in         
// compliance with the License.  You may obtain a copy of the License at    
// http://www.redhat.com/                                                   
//                                                                          
// Software distributed under the License is distributed on an "AS IS"      
// basis, WITHOUT WARRANTY OF ANY KIND, either express or implied.  See the 
// License for the specific language governing rights and limitations under 
// the License.                                                             
//                                                                          
// The Original Code is eCos - Embedded Configurable Operating System,      
// released September 30, 1998.                                             
//                                                                          
// The Initial Developer of the Original Code is Red Hat.                   
// Portions created by Red Hat are                                          
// Copyright (C) 1998, 1999, 2000 Red Hat, Inc.                             
// All Rights Reserved.                                                     
// -------------------------------------------                              
//                                                                          
//####COPYRIGHTEND####
//===========================================================================
//#####DESCRIPTIONBEGIN####
//
// Author(s):   jlarmour
// Contributors:  jlarmour
// Date:        1998-02-13
// Purpose:     
// Description: 
// Usage:       
//
//####DESCRIPTIONEND####
//
//===========================================================================
//
// This code is based on original code with the following copyright:
//
/*-
 * 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. 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.
 */


// CONFIGURATION

#include <pkgconf/libc.h>   // Configuration header

// Include the C library? And do we want the stdio stuff?
#if defined(CYGPKG_LIBC_STDIO)

// INCLUDES

#include <cyg/infra/cyg_type.h>   // Common type definitions and support
#include <stdarg.h>               // Variable argument definitions
#include <stdio.h>                // Standard header for all stdio files
#include "clibincl/stringsupp.hxx"// _memchr() and _strlen() functions
#include "clibincl/stream.hxx"    // C library streams

// EXPORTED SYMBOLS

externC int 
vfnprintf ( FILE *, size_t, const char *, va_list ) 
    CYGPRI_LIBC_WEAK_ALIAS("_vfnprintf");


#ifdef CYGSEM_LIBC_STDIO_PRINTF_FLOATING_POINT

# include <float.h>      // for DBL_DIG etc. below
# include <math.h>       // for modf()
# include <sys/ieeefp.h> // Cyg_libm_ieee_double_shape_type

# define MAXFRACT  DBL_DIG
# define MAXEXP    DBL_MAX_10_EXP

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

static int
cvt( double, int, int, char *, int, char *, char * );

#else // ifdef CYGSEM_LIBC_STDIO_PRINTF_FLOATING_POINT

# define BUF            40

#endif // ifdef CYGSEM_LIBC_STDIO_PRINTF_FLOATING_POINT

/*
 * Actual printf innards.
 *
 * This code is large and complicated...
 */



/*
 * 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 */

static int
__mbtowc(char *pwc, const char *s, size_t n)
{
        if (s == NULL)
                return 0;
        if (n == 0)
                return -1;
        if (pwc)
                *pwc = (char) *s;
        return (*s != '\0');
}

externC int 
_vfnprintf ( FILE *stream, size_t n, const char *format, va_list arg)
{
        char *fmt;     /* format string */
        int ch;        /* character from fmt */
        int x, y;      /* handy integers (short term usage) */
        char *cp;      /* handy char pointer (short term usage) */
        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) */
        char wc;

#define quad_t    long long
#define u_quad_t  unsigned long long

        u_quad_t _uquad;        /* integer arguments %[diouxX] */
        enum { OCT, DEC, HEX } base;/* base for [diouxX] conversion */
        int dprec;              /* a copy of prec if [diouxX], 0 otherwise */
        int fieldsz;            /* field size expanded by sign, etc */
        int realsz;             /* field size expanded by dprec */
        int size;               /* size of converted field or string */
        char *xdigs;            /* digits for [xX] conversion */
#define NIOV 8
        char buf[BUF];          /* space for %c, %[diouxX], %[eEfgG] */
        char ox[2];             /* space for 0x hex-prefix */
#ifdef CYGSEM_LIBC_STDIO_PRINTF_FLOATING_POINT
        char softsign;          /* temporary negative sign for floats */
        double _double;         /* double precision arguments %[eEfgG] */
        int fpprec;             /* `extra' floating precision in [eEfgG] */
#endif

        /*
         * 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 char blanks[PADSIZE] =
         {' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' ',' '};
        static char zeroes[PADSIZE] =
         {'0','0','0','0','0','0','0','0','0','0','0','0','0','0','0','0'};

#define MIN(a, b) ((a) < (b) ? (a) : (b))

        /*
         * BEWARE, these `goto error' on error, and PAD uses `n'.
         */
#define PRINT(ptr, len)                                                      \
CYG_MACRO_START                                                              \
    cyg_ucount32 length = MIN( (cyg_ucount32) len, n - ret - 1);             \
    if (((Cyg_StdioStream *)stream)->write( (const cyg_uint8 *)ptr,          \
                                            length, &length ))               \
        goto error;                                                          \
    if (length < (cyg_ucount32)len) {                                        \
        ret += length;                                                       \
        goto done;                                                           \
    }                                                                        \
CYG_MACRO_END


#define PAD(howmany, with)                                                   \
CYG_MACRO_START                                                              \
    if ((x = (howmany)) > 0) {                                               \
        while (x > PADSIZE) {                                                \
            PRINT(with, PADSIZE);                                            \
            x -= PADSIZE;                                                    \
        }                                                                    \
        PRINT(with, x);                                                      \
    }                                                                        \
CYG_MACRO_END

#define FLUSH()                                                              \
CYG_MACRO_START                                                              \
    if (((Cyg_StdioStream *)stream)->flush_output())                         \
                     goto error;                                             \
CYG_MACRO_END

        /*
         * To extend shorts properly, we need both signed and unsigned
         * argument extraction methods.
         */

#define SARG() \
        (flags&QUADINT ? va_arg(arg, cyg_int64) : \
            flags&LONGINT ? va_arg(arg, cyg_int32) : \
            flags&SHORTINT ? (long)va_arg(arg, cyg_int32) : \
            (long)va_arg(arg, cyg_int32))
#define UARG() \
        (flags&QUADINT ? va_arg(arg, cyg_uint64) : \
            flags&LONGINT ? va_arg(arg, cyg_uint32) : \
            flags&SHORTINT ? (unsigned long)va_arg(arg, cyg_uint32) : \
            (unsigned long)va_arg(arg, cyg_uint32))


        xdigs = NULL;  // stop compiler whinging
        fmt = (char *)format;
        ret = 0;

        /*
         * Scan the format for conversions (`%' character).
         */
        for (;;) {
                cp = (char *)fmt;
                while ((x = __mbtowc(&wc, fmt, 1)) > 0) {
                        fmt += x;
                        if (wc == '%') {
                                fmt--;
                                break;
                        }
                }
                if ((y = fmt - cp) != 0) {
                        PRINT(cp, y);
                        ret += y;
                }
                if ((x <= 0) || (ret >= (int)n))  // @@@ this check with n isn't good enough
                        goto done;
                fmt++;          /* skip over '%' */

                flags = 0;
                dprec = 0;
#ifdef CYGSEM_LIBC_STDIO_PRINTF_FLOATING_POINT
                fpprec = 0;
#endif
                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(arg, int)) >= 0)
                                goto rflag;