snprintf.c File Reference

#include <ctype.h>
#include <stdlib.h>
#include <stdarg.h>
#include <string.h>
#include <sys/types.h>

Include dependency graph for snprintf.c:

Go to the source code of this file.

Defines
#define	SCOPE
#define	WIDE_INT   long
#define	FALSE   0
#define	TRUE   1
#define	NUL   '\0'
#define	S_NULL   "(null)"
#define	S_NULL_LEN   6
#define	FLOAT_DIGITS   6
#define	EXPONENT_LENGTH   10
#define	NUM_BUF_SIZE   512
#define	INS_CHAR(c, sp, bep, cc)
#define	NUM(c)   ( c - '0' )
#define	STR_TO_DEC(str, num)
#define	FIX_PRECISION(adjust, precision, s, s_len)
#define	PAD(width, len, ch)
#define	PREFIX(str, length, ch)   *--str = ch ; length++ ; has_prefix = YES
Typedefs
typedef WIDE_INT	wide_int
typedef unsigned WIDE_INT	u_wide_int
typedef int	bool_int
Enumerations
enum	boolean_e { NO = 0, YES = 1 }
Functions
static char *	conv_10 (wide_int num, bool_int is_unsigned, bool_int *is_negative, char *buf_end, int *len)
SCOPE int	vsnprintf (char *str, size_t size, const char *fmt, va_list ap)
SCOPE int	snprintf (char *str, size_t size, const char *fmt,...)
static char *	conv_fp (char format, double num, boolean_e add_dp, int precision, bool_int *is_negative, char buf[], int *len)
static char *	conv_p2 (u_wide_int num, int nbits, char format, char *buf_end, int *len)

---

Define Documentation

#define EXPONENT_LENGTH   10

Definition at line 93 of file snprintf.c.

Referenced by conv_fp().

#define FALSE   0

Definition at line 83 of file snprintf.c.

#define FIX_PRECISION	(	adjust,
		precision,
		s,
		s_len		)

Value:

if ( adjust )                                                   \
                while ( s_len < precision ) {                           \
                        *--s = '0' ;                                    \
                        s_len++ ;                                       \
        }

Definition at line 137 of file snprintf.c.

Referenced by vsnprintf().

#define FLOAT_DIGITS   6

Definition at line 92 of file snprintf.c.

Referenced by vsnprintf().

#define INS_CHAR	(	c,
		sp,
		bep,
		cc		)

Value:

{                                                               \
            if ( sp < bep )                                             \
                *sp++ = c ;                                             \
            cc++ ;                                                      \
        }

Definition at line 115 of file snprintf.c.

Referenced by vsnprintf().

#define NUL   '\0'

Definition at line 87 of file snprintf.c.

Referenced by display_string(), move_left(), move_right(), strip_blank(), and vsnprintf().

#define NUM

(

c

)

( c - '0' )

Definition at line 122 of file snprintf.c.

#define NUM_BUF_SIZE   512

Definition at line 102 of file snprintf.c.

Referenced by vsnprintf().

#define PAD	(	width,
		len,
		ch		)

Value:

do {                                                            \
                INS_CHAR( ch, sp, bep, cc ) ;                           \
                width-- ;                                               \
        } while ( width > len )

Definition at line 148 of file snprintf.c.

Referenced by vsnprintf().

#define PREFIX	(	str,
		length,
		ch		)	*--str = ch ; length++ ; has_prefix = YES

Definition at line 159 of file snprintf.c.

#define S_NULL   "(null)"

Definition at line 89 of file snprintf.c.

Referenced by vsnprintf().

#define S_NULL_LEN   6

Definition at line 90 of file snprintf.c.

Referenced by vsnprintf().

#define SCOPE

Definition at line 71 of file snprintf.c.

#define STR_TO_DEC	(	str,
		num		)

Value:

num = NUM( *str++ ) ;                                           \
        while ( isdigit( *str ) ) {                                     \
                num *= 10 ;                                             \
                num += NUM( *str++ ) ;                                  \
        }

Definition at line 124 of file snprintf.c.

Referenced by vsnprintf().

#define TRUE   1

Definition at line 84 of file snprintf.c.

#define WIDE_INT   long

Definition at line 75 of file snprintf.c.

---

Typedef Documentation

typedef int bool_int

Definition at line 80 of file snprintf.c.

typedef unsigned WIDE_INT u_wide_int

Definition at line 79 of file snprintf.c.

typedef WIDE_INT wide_int

Definition at line 78 of file snprintf.c.

---

Enumeration Type Documentation

enum boolean_e

Enumerator:

NO
YES

Definition at line 95 of file snprintf.c.

{ NO = 0, YES = 1 } boolean_e ;

---

Function Documentation

static char * conv_10	(	wide_int	num,
		bool_int	is_unsigned,
		bool_int *	is_negative,
		char *	buf_end,
		int *	len
	)			[static]

Definition at line 310 of file snprintf.c.

References FALSE, p, and t.

Referenced by conv_fp(), and vsnprintf().

{
    char *p = buf_end;
    u_wide_int magnitude;

    if (is_unsigned) {
        magnitude = (u_wide_int) num;
        *is_negative = FALSE;
    } else {
        *is_negative = (num < 0);

        /*
         * On a 2's complement machine, negating the most negative integer 
         * results in a number that cannot be represented as a signed integer.
         * Here is what we do to obtain the number's magnitude:
         *              a. add 1 to the number
         *              b. negate it (becomes positive)
         *              c. convert it to unsigned
         *              d. add 1
         */
        if (*is_negative) {
            wide_int t = num + 1;

            magnitude = ((u_wide_int) - t) + 1;
        } else
            magnitude = (u_wide_int) num;
    }

    /*
     * We use a do-while loop so that we write at least 1 digit 
     */
    do {
        register u_wide_int new_magnitude = magnitude / 10;

        *--p = magnitude - new_magnitude * 10 + '0';
        magnitude = new_magnitude;
    }
    while (magnitude);

    *len = buf_end - p;
    return (p);
}

Here is the caller graph for this function:

static char* conv_fp	(	char	format,
		double	num,
		boolean_e	add_dp,
		int	precision,
		bool_int *	is_negative,
		char	buf[],
		int *	len
	)			[static]

Definition at line 193 of file snprintf.c.

References conv_10(), EXPONENT_LENGTH, FALSE, p, and s.

Referenced by vsnprintf().

{
    char *s = buf;
    char *p;
    int decimal_point;

    if (format == 'f')
        p = fcvt(num, precision, &decimal_point, is_negative);
    else                               /* either e or E format */
        p = ecvt(num, precision + 1, &decimal_point, is_negative);

    /*
     * Check for Infinity and NaN
     */
    if (isalpha(*p)) {
        *len = strlen(strcpy(buf, p));
        *is_negative = FALSE;
        return (buf);
    }
    if (format == 'f')
        if (decimal_point <= 0) {
            *s++ = '0';
            if (precision > 0) {
                *s++ = '.';
                while (decimal_point++ < 0)
                    *s++ = '0';
            } else if (add_dp)
                *s++ = '.';
        } else {
            while (decimal_point-- > 0)
                *s++ = *p++;
            if (precision > 0 || add_dp)
                *s++ = '.';
    } else {
        *s++ = *p++;
        if (precision > 0 || add_dp)
            *s++ = '.';
    }

    /*
     * copy the rest of p, the NUL is NOT copied
     */
    while (*p)
        *s++ = *p++;

    if (format != 'f') {
        char temp[EXPONENT_LENGTH];    /* for exponent conversion */
        int t_len;
        bool_int exponent_is_negative;

        *s++ = format;                 /* either e or E */
        decimal_point--;
        if (decimal_point != 0) {
            p = conv_10((wide_int) decimal_point, FALSE, &exponent_is_negative,
                &temp[EXPONENT_LENGTH], &t_len);
            *s++ = exponent_is_negative ? '-' : '+';

            /*
             * Make sure the exponent has at least 2 digits
             */
            if (t_len == 1)
                *s++ = '0';
            while (t_len--)
                *s++ = *p++;
        } else {
            *s++ = '+';
            *s++ = '0';
            *s++ = '0';
        }
    }
    *len = s - buf;
    return (buf);
}

Here is the call graph for this function:

Here is the caller graph for this function:

static char* conv_p2	(	u_wide_int	num,
		int	nbits,
		char	format,
		char *	buf_end,
		int *	len
	)			[static]

Definition at line 279 of file snprintf.c.

References p.

Referenced by vsnprintf().

{
    int mask = (1 << nbits) - 1;
    char *p = buf_end;
    static char low_digits[] = "0123456789abcdef";
    static char upper_digits[] = "0123456789ABCDEF";
    char *digits = (format == 'X') ? upper_digits : low_digits;

    do {
        *--p = digits[num & mask];
        num >>= nbits;
    }
    while (num);

    *len = buf_end - p;
    return (p);
}

Here is the caller graph for this function:

SCOPE int snprintf	(	char *	str,
		size_t	size,
		const char *	fmt,
			...
	)

Definition at line 175 of file snprintf.c.

References vsnprintf().

{
    int cc;
    va_list ap;

    va_start(ap, fmt);
    cc = vsnprintf(str, size, fmt, ap);
    va_end(ap);
    return cc;
}

Here is the call graph for this function:

SCOPE int vsnprintf	(	char *	str,
		size_t	size,
		const char *	fmt,
		va_list	ap
	)

Definition at line 358 of file snprintf.c.

References conv_10(), conv_fp(), conv_p2(), FIX_PRECISION, FLOAT_DIGITS, i, INS_CHAR, LEFT, NO, NUL, NULL, NUM_BUF_SIZE, PAD, RIGHT, s, S_NULL, S_NULL_LEN, sp(), STR_TO_DEC, strchr(), and YES.

Referenced by C2F(), LOGGER_log(), PLD_dprintf(), sciprint(), sciprint2(), sciprint_full(), sciprint_l(), sciprint_nd(), snprintf(), and XmuSnprintf().

{
    char *sp;
    char *bep;
    int cc = 0;
    int i;

    char *s;
    char *q;
    int s_len;

    int min_width;
    int precision;
    enum {
        LEFT, RIGHT
    } adjust;
    char pad_char;
    char prefix_char;

    double fp_num;
    wide_int i_num;
    u_wide_int ui_num;

    char num_buf[NUM_BUF_SIZE];
    char char_buf[2];                  /* for printing %% and %<unknown> */

    /*
     * Flag variables
     */
    boolean_e is_long;
    boolean_e alternate_form;
    boolean_e print_sign;
    boolean_e print_blank;
    boolean_e adjust_precision;
    boolean_e adjust_width;
    bool_int is_negative;

    if (size == 0)
        return 0;

    sp = str;
    bep = str + size - 1;

    while (*fmt) {
        if (*fmt != '%') {
            INS_CHAR(*fmt, sp, bep, cc);
        } else {
            /*
             * Default variable settings
             */
            adjust = RIGHT;
            alternate_form = print_sign = print_blank = NO;
            pad_char = ' ';
            prefix_char = NUL;

            fmt++;

            /*
             * Try to avoid checking for flags, width or precision
             */
            if (isascii(*fmt) && !islower(*fmt)) {
                /*
                 * Recognize flags: -, #, BLANK, +
                 */
                for (;; fmt++) {
                    if (*fmt == '-')
                        adjust = LEFT;
                    else if (*fmt == '+')
                        print_sign = YES;
                    else if (*fmt == '#')
                        alternate_form = YES;
                    else if (*fmt == ' ')
                        print_blank = YES;
                    else if (*fmt == '0')
                        pad_char = '0';
                    else
                        break;
                }

                /*
                 * Check if a width was specified
                 */
                if (isdigit(*fmt)) {
                    STR_TO_DEC(fmt, min_width);
                    adjust_width = YES;
                } else if (*fmt == '*') {
                    min_width = va_arg(ap, int);

                    fmt++;
                    adjust_width = YES;
                    if (min_width < 0) {
                        adjust = LEFT;
                        min_width = -min_width;
                    }
                } else
                    adjust_width = NO;

                /*
                 * Check if a precision was specified
                 *
                 * XXX: an unreasonable amount of precision may be specified
                 *      resulting in overflow of num_buf. Currently we
                 *      ignore this possibility.
                 */
                if (*fmt == '.') {
                    adjust_precision = YES;
                    fmt++;
                    if (isdigit(*fmt)) {
                        STR_TO_DEC(fmt, precision);
                    } else if (*fmt == '*') {
                        precision = va_arg(ap, int);

                        fmt++;
                        if (precision < 0)
                            precision = 0;
                    } else
                        precision = 0;
                } else
                    adjust_precision = NO;
            } else
                adjust_precision = adjust_width = NO;

            /*
             * Modifier check
             */
            if (*fmt == 'l') {
                is_long = YES;
                fmt++;
            } else
                is_long = NO;

            /*
             * Argument extraction and printing.
             * First we determine the argument type.
             * Then, we convert the argument to a string.
             * On exit from the switch, s points to the string that
             * must be printed, s_len has the length of the string
             * The precision requirements, if any, are reflected in s_len.
             *
             * NOTE: pad_char may be set to '0' because of the 0 flag.
             *                      It is reset to ' ' by non-numeric formats
             */
            switch (*fmt) {
            case 'd':
            case 'i':
            case 'u':
                if (is_long)
                    i_num = va_arg(ap, wide_int);
                else
                    i_num = (wide_int) va_arg(ap, int);

                s = conv_10(i_num, (*fmt) == 'u', &is_negative,
                    &num_buf[NUM_BUF_SIZE], &s_len);
                FIX_PRECISION(adjust_precision, precision, s, s_len);

                if (*fmt != 'u') {
                    if (is_negative)
                        prefix_char = '-';
                    else if (print_sign)
                        prefix_char = '+';
                    else if (print_blank)
                        prefix_char = ' ';
                }
                break;

            case 'o':
                if (is_long)
                    ui_num = va_arg(ap, u_wide_int);
                else
                    ui_num = (u_wide_int) va_arg(ap, unsigned int);

                s = conv_p2(ui_num, 3, *fmt,
                    &num_buf[NUM_BUF_SIZE], &s_len);
                FIX_PRECISION(adjust_precision, precision, s, s_len);
                if (alternate_form && *s != '0') {
                    *--s = '0';
                    s_len++;
                }
                break;

            case 'x':
            case 'X':
                if (is_long)
                    ui_num = (u_wide_int) va_arg(ap, u_wide_int);
                else
                    ui_num = (u_wide_int) va_arg(ap, unsigned int);

                s = conv_p2(ui_num, 4, *fmt,
                    &num_buf[NUM_BUF_SIZE], &s_len);
                FIX_PRECISION(adjust_precision, precision, s, s_len);
                if (alternate_form && i_num != 0) {
                    *--s = *fmt;       /* 'x' or 'X' */
                    *--s = '0';
                    s_len += 2;
                }
                break;

            case 's':
                s = va_arg(ap, char *);

                if (s != NULL) {
                    s_len = strlen(s);
                    if (adjust_precision && precision < s_len)
                        s_len = precision;
                } else {
                    s = S_NULL;
                    s_len = S_NULL_LEN;
                }
                pad_char = ' ';
                break;

            case 'f':
            case 'e':
            case 'E':
                fp_num = va_arg(ap, double);

                s = conv_fp(*fmt, fp_num, alternate_form,
                    (adjust_precision == NO) ? FLOAT_DIGITS : precision,
                    &is_negative, &num_buf[1], &s_len);
                if (is_negative)
                    prefix_char = '-';
                else if (print_sign)
                    prefix_char = '+';
                else if (print_blank)
                    prefix_char = ' ';
                break;

            case 'g':
            case 'G':
                if (adjust_precision == NO)
                    precision = FLOAT_DIGITS;
                else if (precision == 0)
                    precision = 1;
                /*
                 * We use &num_buf[ 1 ], so that we have room for the sign
                 */
                s = gcvt(va_arg(ap, double), precision, &num_buf[1]);

                if (*s == '-')
                    prefix_char = *s++;
                else if (print_sign)
                    prefix_char = '+';
                else if (print_blank)
                    prefix_char = ' ';

                s_len = strlen(s);

                if (alternate_form && (q = strchr(s, '.')) == NULL)
                    s[s_len++] = '.';
                if (*fmt == 'G' && (q = strchr(s, 'e')) != NULL)
                    *q = 'E';
                break;

            case 'c':
                char_buf[0] = (char)(va_arg(ap, int));

                s = &char_buf[0];
                s_len = 1;
                pad_char = ' ';
                break;

            case '%':
                char_buf[0] = '%';
                s = &char_buf[0];
                s_len = 1;
                pad_char = ' ';
                break;

            case 'n':
                *(va_arg(ap, int *)) = cc;

                break;

                /*
                 * If the pointer size is equal to the size of an unsigned
                 * integer we convert the pointer to a hex number, otherwise 
                 * we print "%p" to indicate that we don't handle "%p".
                 */
            case 'p':
                ui_num = (u_wide_int) va_arg(ap, void *);

                if (sizeof(void *) <= sizeof(u_wide_int))
                        s = conv_p2(ui_num, 4, 'x',
                        &num_buf[NUM_BUF_SIZE], &s_len);

                else {
                    s = "%p";
                    s_len = 2;
                }
                pad_char = ' ';
                break;

            case NUL:
                /*
                 * The last character of the format string was %.
                 * We ignore it.
                 */
                continue;

                /*
                 * The default case is for unrecognized %'s.
                 * We print %<char> to help the user identify what
                 * option is not understood.
                 * This is also useful in case the user wants to pass
                 * the output of __sio_converter to another function
                 * that understands some other %<char> (like syslog).
                 * Note that we can't point s inside fmt because the
                 * unknown <char> could be preceded by width etc.
                 */
            default:
                char_buf[0] = '%';
                char_buf[1] = *fmt;
                s = char_buf;
                s_len = 2;
                pad_char = ' ';
                break;
            }

            if (prefix_char != NUL) {
                *--s = prefix_char;
                s_len++;
            }
            if (adjust_width && adjust == RIGHT && min_width > s_len) {
                if (pad_char == '0' && prefix_char != NUL) {
                    INS_CHAR(*s, sp, bep, cc)
                        s++;
                    s_len--;
                    min_width--;
                }
                PAD(min_width, s_len, pad_char);
            }
            /*
             * Print the string s. 
             */
            for (i = s_len; i != 0; i--) {
                INS_CHAR(*s, sp, bep, cc);
                s++;
            }

            if (adjust_width && adjust == LEFT && min_width > s_len)
                PAD(min_width, s_len, pad_char);
        }
        fmt++;
    }
    if (cc < size)
        str[cc] = NUL;
    else
        str[size - 1] = NUL;
    return cc;
}

Here is the call graph for this function:

Here is the caller graph for this function:

---