vsprintf.h File Reference

printf() and friends More...

#include <stdint.h>
#include <stdarg.h>
#include <stdio.h>

Go to the source code of this file.

Data Structures
struct	printf_context
	A printf context. More...
Functions
	FILE_LICENCE (GPL2_OR_LATER)
size_t	vcprintf (struct printf_context *ctx, const char *fmt, va_list args)
	Write a formatted string to a printf context.
int	vssnprintf (char *buf, ssize_t ssize, const char *fmt, va_list args)
	Version of vsnprintf() that accepts a signed buffer size.
int	__attribute__ ((format(printf, 3, 4))) ssnprintf(char *buf
Variables
int ssize_t	ssize
int ssize_t const char *	fmt

---

Detailed Description

printf() and friends

Etherboot's printf() functions understand the following subset of the standard C printf()'s format specifiers:

• Flag characters
  • '#' - Alternate form (i.e. "0x" prefix)
  • '0' - Zero-pad
• Field widths
• Length modifiers
  • 'hh' - Signed / unsigned char
  • 'h' - Signed / unsigned short
  • 'l' - Signed / unsigned long
  • 'll' - Signed / unsigned long long
  • 'z' - Signed / unsigned size_t
• Conversion specifiers
  • 'd' - Signed decimal
  • 'x','X' - Unsigned hexadecimal
  • 'c' - Character
  • 's' - String
  • 'p' - Pointer

Hexadecimal numbers are always zero-padded to the specified field width (if any); decimal numbers are always space-padded. Decimal long longs are not supported.

Definition in file vsprintf.h.

---

Function Documentation

FILE_LICENCE

(

GPL2_OR_LATER

)

size_t vcprintf	(	struct printf_context *	ctx,
		const char *	fmt,
		va_list	args
	)

Write a formatted string to a printf context.

Parameters:

	ctx	Context
	fmt	Format string
	args	Arguments corresponding to the format string

Return values:

len

Length of formatted string

Definition at line 165 of file vsprintf.c.

References ALT_FORM, cputchar(), format_decimal(), format_hex(), INT_LEN, LCASE, printf_context::len, SIZE_T_LEN, type_sizes, and va_arg.

Referenced by vprintf(), vsnprintf(), and vw_printw().

                                                                              {
        int flags;
        int width;
        uint8_t *length;
        char *ptr;
        char tmp_buf[32]; /* 32 is enough for all numerical formats.
                           * Insane width fields could overflow this buffer. */

        /* Initialise context */
        ctx->len = 0;

        for ( ; *fmt ; fmt++ ) {
                /* Pass through ordinary characters */
                if ( *fmt != '%' ) {
                        cputchar ( ctx, *fmt );
                        continue;
                }
                fmt++;
                /* Process flag characters */
                flags = 0;
                for ( ; ; fmt++ ) {
                        if ( *fmt == '#' ) {
                                flags |= ALT_FORM;
                        } else if ( *fmt == '0' ) {
                                /* We always 0-pad hex and space-pad decimal */
                        } else {
                                /* End of flag characters */
                                break;
                        }
                }
                /* Process field width */
                width = 0;
                for ( ; ; fmt++ ) {
                        if ( ( ( unsigned ) ( *fmt - '0' ) ) < 10 ) {
                                width = ( width * 10 ) + ( *fmt - '0' );
                        } else {
                                break;
                        }
                }
                /* We don't do floating point */
                /* Process length modifier */
                length = &type_sizes[INT_LEN];
                for ( ; ; fmt++ ) {
                        if ( *fmt == 'h' ) {
                                length--;
                        } else if ( *fmt == 'l' ) {
                                length++;
                        } else if ( *fmt == 'z' ) {
                                length = &type_sizes[SIZE_T_LEN];
                        } else {
                                break;
                        }
                }
                /* Process conversion specifier */
                ptr = tmp_buf + sizeof ( tmp_buf ) - 1;
                *ptr = '\0';
                if ( *fmt == 'c' ) {
                        cputchar ( ctx, va_arg ( args, unsigned int ) );
                } else if ( *fmt == 's' ) {
                        ptr = va_arg ( args, char * );
                        if ( ! ptr )
                                ptr = "<NULL>";
                } else if ( *fmt == 'p' ) {
                        intptr_t ptrval;

                        ptrval = ( intptr_t ) va_arg ( args, void * );
                        ptr = format_hex ( ptr, ptrval, width, 
                                           ( ALT_FORM | LCASE ) );
                } else if ( ( *fmt & ~0x20 ) == 'X' ) {
                        unsigned long long hex;

                        flags |= ( *fmt & 0x20 ); /* LCASE */
                        if ( *length >= sizeof ( unsigned long long ) ) {
                                hex = va_arg ( args, unsigned long long );
                        } else if ( *length >= sizeof ( unsigned long ) ) {
                                hex = va_arg ( args, unsigned long );
                        } else {
                                hex = va_arg ( args, unsigned int );
                        }
                        ptr = format_hex ( ptr, hex, width, flags );
                } else if ( ( *fmt == 'd' ) || ( *fmt == 'i' ) ){
                        signed long decimal;

                        if ( *length >= sizeof ( signed long ) ) {
                                decimal = va_arg ( args, signed long );
                        } else {
                                decimal = va_arg ( args, signed int );
                        }
                        ptr = format_decimal ( ptr, decimal, width );
                } else {
                        *(--ptr) = *fmt;
                }
                /* Write out conversion result */
                for ( ; *ptr ; ptr++ ) {
                        cputchar ( ctx, *ptr );
                }
        }

        return ctx->len;
}

int vssnprintf	(	char *	buf,
		ssize_t	ssize,
		const char *	fmt,
		va_list	args
	)

Version of vsnprintf() that accepts a signed buffer size.

Parameters:

	buf	Buffer into which to write the string
	size	Size of buffer
	fmt	Format string
	args	Arguments corresponding to the format string

Return values:

len

Length of formatted string

Definition at line 352 of file vsprintf.c.

References vsnprintf().

Referenced by ssnprintf().

                                                                           {

        /* Treat negative buffer size as zero buffer size */
        if ( ssize < 0 )
                ssize = 0;

        /* Hand off to vsnprintf */
        return vsnprintf ( buf, ssize, fmt, args );
}

int __attribute__

(

(format(printf, 3, 4))

)

---

Variable Documentation

int ssize_t ssize

Definition at line 72 of file vsprintf.h.

int int size_t const char int const char * fmt

Definition at line 72 of file vsprintf.h.