stdio.h File Reference

#include <debug.h>
#include <stdarg.h>
#include <stdbool.h>
#include <stddef.h>
#include <stdint.h>

Include dependency graph for stdio.h:

This graph shows which files directly or indirectly include this file:

Go to the source code of this file.

Macros
#define	STDIN_FILENO   0
#define	STDOUT_FILENO   1
#define	sprintf   dont_use_sprintf_use_snprintf
#define	vsprintf   dont_use_vsprintf_use_vsnprintf

Functions
int	printf (const char *,...) PRINTF_FORMAT(1
int int	snprintf (char *, size_t, const char *,...) PRINTF_FORMAT(3
int int int	vprintf (const char *, va_list) PRINTF_FORMAT(1
int int int int	vsnprintf (char *, size_t, const char *, va_list) PRINTF_FORMAT(3
int int int int int	putchar (int)
int	puts (const char *)
void	hex_dump (uintptr_t ofs, const void *, size_t size, bool ascii)
void	__vprintf (const char *format, va_list args, void(*output)(char, void *), void *aux)
void	__printf (const char *format, void(*output)(char, void *), void *aux,...)

Macro Definition Documentation

sprintf

#define sprintf   dont_use_sprintf_use_snprintf

STDIN_FILENO

#define STDIN_FILENO   0

STDOUT_FILENO

#define STDOUT_FILENO   1

vsprintf

#define vsprintf   dont_use_vsprintf_use_vsnprintf

Function Documentation

__printf()

void __printf	(	const char *	format,
		void(*)(char, void *)	output,
		void *	aux,
			...
	)

                                                       {
    va_list args;
 
    va_start (args, aux);
    __vprintf (format, args, output, aux);
    va_end (args);
}

Here is the call graph for this function:

Here is the caller graph for this function:

__vprintf()

void __vprintf	(	const char *	format,
		va_list	args,
		void(*)(char, void *)	output,
		void *	aux
	)

                                                  {
    for (; *format != '\0'; format++) {
        struct printf_conversion c;
 
        /* Literally copy non-conversions to output. */
        if (*format != '%') {
            output (*format, aux);
            continue;
        }
        format++;
 
        /* %% => %. */
        if (*format == '%') {
            output ('%', aux);
            continue;
        }
 
        /* Parse conversion specifiers. */
        format = parse_conversion (format, &c, &args);
 
        /* Do conversion. */
        switch (*format) {
            case 'd':
            case 'i':
                {
                    /* Signed integer conversions. */
                    intmax_t value;
 
                    switch (c.type) {
                        case CHAR:
                            value = (signed char) va_arg (args, int);
                            break;
                        case SHORT:
                            value = (short) va_arg (args, int);
                            break;
                        case INT:
                            value = va_arg (args, int);
                            break;
                        case INTMAX:
                            value = va_arg (args, intmax_t);
                            break;
                        case LONG:
                            value = va_arg (args, long);
                            break;
                        case LONGLONG:
                            value = va_arg (args, long long);
                            break;
                        case PTRDIFFT:
                            value = va_arg (args, ptrdiff_t);
                            break;
                        case SIZET:
                            value = va_arg (args, size_t);
                            if (value > SIZE_MAX / 2)
                                value = value - SIZE_MAX - 1;
                            break;
                        default:
                            NOT_REACHED ();
                    }
 
                    format_integer (value < 0 ? -value : value,
                            true, value < 0, &base_d, &c, output, aux);
                }
                break;
 
            case 'o':
            case 'u':
            case 'x':
            case 'X':
                {
                    /* Unsigned integer conversions. */
                    uintmax_t value;
                    const struct integer_base *b;
 
                    switch (c.type) {
                        case CHAR:
                            value = (unsigned char) va_arg (args, unsigned);
                            break;
                        case SHORT:
                            value = (unsigned short) va_arg (args, unsigned);
                            break;
                        case INT:
                            value = va_arg (args, unsigned);
                            break;
                        case INTMAX:
                            value = va_arg (args, uintmax_t);
                            break;
                        case LONG:
                            value = va_arg (args, unsigned long);
                            break;
                        case LONGLONG:
                            value = va_arg (args, unsigned long long);
                            break;
                        case PTRDIFFT:
                            value = va_arg (args, ptrdiff_t);
#if UINTMAX_MAX != PTRDIFF_MAX
                            value &= ((uintmax_t) PTRDIFF_MAX << 1) | 1;
#endif
                            break;
                        case SIZET:
                            value = va_arg (args, size_t);
                            break;
                        default:
                            NOT_REACHED ();
                    }
 
                    switch (*format) {
                        case 'o': b = &base_o; break;
                        case 'u': b = &base_d; break;
                        case 'x': b = &base_x; break;
                        case 'X': b = &base_X; break;
                        default: NOT_REACHED ();
                    }
 
                    format_integer (value, false, false, b, &c, output, aux);
                }
                break;
 
            case 'c':
                {
                    /* Treat character as single-character string. */
                    char ch = va_arg (args, int);
                    format_string (&ch, 1, &c, output, aux);
                }
                break;
 
            case 's':
                {
                    /* String conversion. */
                    const char *s = va_arg (args, char *);
                    if (s == NULL)
                        s = "(null)";
 
                    /* Limit string length according to precision.
Note: if c.precision == -1 then strnlen() will get
SIZE_MAX for MAXLEN, which is just what we want. */
                    format_string (s, strnlen (s, c.precision), &c, output, aux);
                }
                break;
 
            case 'p':
                {
                    /* Pointer conversion.
                       Format pointers as %#x. */
                    void *p = va_arg (args, void *);
 
                    c.flags = POUND;
                    format_integer ((uintptr_t) p, false, false,
                            &base_x, &c, output, aux);
                }
                break;
 
            case 'f':
            case 'e':
            case 'E':
            case 'g':
            case 'G':
            case 'n':
                /* We don't support floating-point arithmetic,
                   and %n can be part of a security hole. */
                __printf ("<<no %%%c in kernel>>", output, aux, *format);
                break;
 
            default:
                __printf ("<<no %%%c conversion>>", output, aux, *format);
                break;
        }
    }
}

Here is the call graph for this function:

Here is the caller graph for this function:

hex_dump()

void hex_dump	(	uintptr_t	ofs,
		const void *	buf_,
		size_t	size,
		bool	ascii
	)

                                                                    {
    const uint8_t *buf = buf_;
    const size_t per_line = 16; /* Maximum bytes per line. */
 
    while (size > 0) {
        size_t start, end, n;
        size_t i;
 
        /* Number of bytes on this line. */
        start = ofs % per_line;
        end = per_line;
        if (end - start > size)
            end = start + size;
        n = end - start;
 
        /* Print line. */
        printf ("%016llx  ", (uintmax_t) ROUND_DOWN (ofs, per_line));
        for (i = 0; i < start; i++)
            printf ("   ");
        for (; i < end; i++)
            printf ("%02hhx%c",
                    buf[i - start], i == per_line / 2 - 1? '-' : ' ');
        if (ascii) {
            for (; i < per_line; i++)
                printf ("   ");
            printf ("|");
            for (i = 0; i < start; i++)
                printf (" ");
            for (; i < end; i++)
                printf ("%c",
                        isprint (buf[i - start]) ? buf[i - start] : '.');
            for (; i < per_line; i++)
                printf (" ");
            printf ("|");
        }
        printf ("\n");
 
        ofs += n;
        buf += n;
        size -= n;
    }
}

Here is the call graph for this function:

Here is the caller graph for this function:

printf()

int printf	(	const char *	,
			...
	)

Here is the caller graph for this function:

putchar()

int int int int int putchar

(

int

c

)

                {
    acquire_console ();
    putchar_have_lock (c);
    release_console ();
 
    return c;
}

Here is the call graph for this function:

Here is the caller graph for this function:

puts()

int puts

(

const char *

s

)

                     {
    acquire_console ();
    while (*s != '\0')
        putchar_have_lock (*s++);
    putchar_have_lock ('\n');
    release_console ();
 
    return 0;
}

Here is the call graph for this function:

snprintf()

int int snprintf	(	char *	,
		size_t	,
		const char *	,
			...
	)

Here is the caller graph for this function:

vprintf()

int int int vprintf	(	const char *	,
		va_list
	)

Here is the caller graph for this function:

vsnprintf()

int int int int vsnprintf	(	char *	,
		size_t	,
		const char *	,
		va_list
	)