WebSVN – HelenOS-historic – Diff – /kernel/trunk/generic/src/printf/printf_core.c


/*
 * Copyright (C) 2001-2004 Jakub Jermar
 * Copyright (C) 2006 Josef Cejka
 * All rights reserved.
 *
 * Redistribution and use in source and binary forms, with or without
 * modification, are permitted provided that the following conditions
 * are met:
 *
 * - Redistributions of source code must retain the above copyright
 *   notice, this list of conditions and the following disclaimer.
 * - 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.
 * - The name of the author may not be used to endorse or promote products
 *   derived from this software without specific prior written permission.
 *
 * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``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 AUTHOR 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.
 */
 
/**
 * @file    print.c
 * @brief   Printing functions.
 */
 
#include <printf/printf_core.h>
#include <putchar.h>
#include <print.h>
#include <synch/spinlock.h>
#include <arch/arg.h>
#include <arch/asm.h>
 
#include <arch.h>
 
SPINLOCK_INITIALIZE(printflock);            /**< printf spinlock */
 
#define __PRINTF_FLAG_PREFIX        0x00000001  /**< show prefixes 0x or 0*/
#define __PRINTF_FLAG_SIGNED        0x00000002  /**< signed / unsigned number */
#define __PRINTF_FLAG_ZEROPADDED    0x00000004  /**< print leading zeroes */
#define __PRINTF_FLAG_LEFTALIGNED   0x00000010  /**< align to left */
#define __PRINTF_FLAG_SHOWPLUS      0x00000020  /**< always show + sign */
#define __PRINTF_FLAG_SPACESIGN     0x00000040  /**< print space instead of plus */
#define __PRINTF_FLAG_BIGCHARS      0x00000080  /**< show big characters */
#define __PRINTF_FLAG_NEGATIVE      0x00000100  /**< number has - sign */
 
#define PRINT_NUMBER_BUFFER_SIZE    (64+5)      /**< Buffer big enought for 64 bit number
                             * printed in base 2, sign, prefix and
                             * 0 to terminate string.. (last one is only for better testing
                             * end of buffer by zero-filling subroutine)*/
 
/** Enumeration of possible arguments types.
 */
typedef enum {
    PrintfQualifierByte = 0,
    PrintfQualifierShort,
    PrintfQualifierInt,
    PrintfQualifierLong,
    PrintfQualifierLongLong,
    PrintfQualifierNative,
    PrintfQualifierPointer
} qualifier_t;
 
static char digits_small[] = "0123456789abcdef";    /**< Small hexadecimal characters */
static char digits_big[] = "0123456789ABCDEF";  /**< Big hexadecimal characters */
 
/** Checks c for a digit.
 * @param c One character.
 * @return nonzero if c is from interval '0 to '9'.
 */
static inline int isdigit(int c)
{
    return ((c >= '0' )&&( c <= '9'));
}
 
/** Compute length of given zero terminated string.
 * @param str Pointer to valid string.
 * @return string length without trailing zero.
 */
static __native strlen(const char *str)
{
    __native counter = 0;
 
    while (str[counter] != 0) {
        counter++;
    }
 
    return counter;
}
 
/** Print count chars from buffer without adding newline
 * @param buf Buffer with size at least count bytes - NULL pointer NOT allowed!
 * @param count
 * @param ps output method and its data
 * @return 0 on success, EOF on fail
 */
static int printf_putnchars(const char * buf, size_t count, struct printf_spec *ps)
{
    if (ps->write((void *)buf, count, ps->data) == count) {
        return 0;
    }
   
    return EOF;
}
 
/** Print string without added newline
 * @param str string to print
 * @param ps write function specification and support data
 * @return 0 on success or EOF on fail
 */
static int printf_putstr(const char * str, struct printf_spec *ps)
{
    size_t count;
   
    if (str == NULL) {
        return printf_putnchars("(NULL)", 6, ps);
    }
 
    count = strlen(str);
 
    if (ps->write((void *) str, count, ps->data) == count) {
        return 0;
    }
   
    return EOF;
}
 
/** Print one character to output
 * @param c one character
 * @param ps output method
 * @return printed character or EOF
 */
static int printf_putchar(int c, struct printf_spec *ps)
{
    unsigned char ch = c;
   
    if (ps->write((void *) &ch, 1, ps->data) == 1) {
        return c;
    }
   
    return EOF;
}
 
/** Print one formatted character
 * @param c character to print
 * @param width
 * @param flags
 * @return number of printed characters or EOF
 */
static int print_char(char c, int width, __u64 flags, struct printf_spec *ps)
{
    int counter = 0;
   
    if (!(flags & __PRINTF_FLAG_LEFTALIGNED)) {
        while (--width > 0) {   /* one space is consumed by character itself hence predecrement */
            /* FIXME: painful slow */
            printf_putchar(' ', ps);   
            ++counter;
        }
    }
   
    if (printf_putchar(c, ps) == EOF) {
        return EOF;
    }
 
    while (--width > 0) { /* one space is consumed by character itself hence predecrement */
        printf_putchar(' ', ps);
        ++counter;
    }
   
    return ++counter;
}
 
/** Print one string
 * @param s string
 * @param width
 * @param precision
 * @param flags
 * @return number of printed characters or EOF
 */
                       
static int print_string(char *s, int width, int precision, __u64 flags, struct printf_spec *ps)
{
    int counter = 0;
    size_t size;
 
    if (s == NULL) {
        return printf_putstr("(NULL)", ps);
    }
   
    size = strlen(s);
 
    /* print leading spaces */
 
    if (precision == 0)
        precision = size;
 
    width -= precision;
   
    if (!(flags & __PRINTF_FLAG_LEFTALIGNED)) {
        while (width-- > 0) {  
            printf_putchar(' ', ps);   
            counter++;
        }
    }
 
    while (precision > size) {
        precision--;
        printf_putchar(' ', ps);   
        ++counter;
    }
   
    if (printf_putnchars(s, precision, ps) == EOF) {
        return EOF;
    }
 
    counter += precision;
 
    while (width-- > 0) {
        printf_putchar(' ', ps);   
        ++counter;
    }
   
    return ++counter;
}
 
 
/** Print number in given base
 *
 * Print significant digits of a number in given
 * base.
 *
 * @param num  Number to print.
 * @param width
 * @param precision
 * @param base Base to print the number in (should
 *             be in range 2 .. 16).
 * @param flags output modifiers
 * @return number of written characters or EOF
 *
 */
static int print_number(__u64 num, int width, int precision, int base , __u64 flags, struct printf_spec *ps)
{
    char *digits = digits_small;
    char d[PRINT_NUMBER_BUFFER_SIZE];   /* this is good enough even for base == 2, prefix and sign */
    char *ptr = &d[PRINT_NUMBER_BUFFER_SIZE - 1];
    int size = 0; /* size of number with all prefixes and signs */
    int number_size; /* size of plain number */
    int written = 0;
    char sgn;
   
    if (flags & __PRINTF_FLAG_BIGCHARS)
        digits = digits_big;   
   
    *ptr-- = 0; /* Put zero at end of string */
 
    if (num == 0) {
        *ptr-- = '0';
        size++;
    } else {
        do {
            *ptr-- = digits[num % base];
            size++;
        } while (num /= base);
    }
   
    number_size = size;
 
    /* Collect sum of all prefixes/signs/... to calculate padding and leading zeroes */
    if (flags & __PRINTF_FLAG_PREFIX) {
        switch(base) {
            case 2: /* Binary formating is not standard, but usefull */
                size += 2;
                break;
            case 8:
                size++;
                break;
            case 16:
                size += 2;
                break;
        }
    }
 
    sgn = 0;
    if (flags & __PRINTF_FLAG_SIGNED) {
        if (flags & __PRINTF_FLAG_NEGATIVE) {
            sgn = '-';
            size++;
        } else if (flags & __PRINTF_FLAG_SHOWPLUS) {
                sgn = '+';
                size++;
            } else if (flags & __PRINTF_FLAG_SPACESIGN) {
                    sgn = ' ';
                    size++;
                }
    }
 
    if (flags & __PRINTF_FLAG_LEFTALIGNED) {
        flags &= ~__PRINTF_FLAG_ZEROPADDED;
    }
 
    /* if number is leftaligned or precision is specified then zeropadding is ignored */
    if (flags & __PRINTF_FLAG_ZEROPADDED) {
        if ((precision == 0) && (width > size)) {
            precision = width - size + number_size;
        }
    }
 
    /* print leading spaces */
    if (number_size > precision) /* We must print whole number not only a part */
        precision = number_size;
 
    width -= precision + size - number_size;
   
    if (!(flags & __PRINTF_FLAG_LEFTALIGNED)) {
        while (width-- > 0) {  
            printf_putchar(' ', ps);   
            written++;
        }
    }
   
    /* print sign */
    if (sgn) {
        printf_putchar(sgn, ps);
        written++;
    }
   
    /* print prefix */
   
    if (flags & __PRINTF_FLAG_PREFIX) {
        switch(base) {
            case 2: /* Binary formating is not standard, but usefull */
                printf_putchar('0', ps);
                if (flags & __PRINTF_FLAG_BIGCHARS) {
                    printf_putchar('B', ps);
                } else {
                    printf_putchar('b', ps);
                }
                written += 2;
                break;
            case 8:
                printf_putchar('o', ps);
                written++;
                break;
            case 16:
                printf_putchar('0', ps);
                if (flags & __PRINTF_FLAG_BIGCHARS) {
                    printf_putchar('X', ps);
                } else {
                    printf_putchar('x', ps);
                }
                written += 2;
                break;
        }
    }
 
    /* print leading zeroes */
    precision -= number_size;
    while (precision-- > 0) {  
        printf_putchar('0', ps);   
        written++;
    }
 
   
    /* print number itself */
 
    written += printf_putstr(++ptr, ps);
   
    /* print ending spaces */
   
    while (width-- > 0) {  
        printf_putchar(' ', ps);   
        written++;
    }
 
    return written;
}
 
 
/** Print formatted string.
 *
 * Print string formatted according to the fmt parameter
 * and variadic arguments. Each formatting directive
 * must have the following form:
 *
 *  \% [ FLAGS ] [ WIDTH ] [ .PRECISION ] [ TYPE ] CONVERSION
 *
 * FLAGS:@n
 *  - "#" Force to print prefix.
 *  For conversion \%o the prefix is 0, for %x and \%X prefixes are 0x and 0X
 *  and for conversion \%b the prefix is 0b.
 *
 *  - "-"   Align to left.
 *
 *  - "+"   Print positive sign just as negative.
 *
 *  - " "   If the printed number is positive and "+" flag is not set, print space in
 *  place of sign.
 *
 *  - "0"   Print 0 as padding instead of spaces. Zeroes are placed between sign and the
 *  rest of the number. This flag is ignored if "-" flag is specified.
 *
 * WIDTH:@n
 *  - Specify minimal width of printed argument. If it is bigger, width is ignored.
 * If width is specified with a "*" character instead of number, width is taken from
 * parameter list. And integer parameter is expected before parameter for processed
 * conversion specification. If this value is negative its absolute value is taken
 * and the "-" flag is set.
 *
 * PRECISION:@n
 *  - Value precision. For numbers it specifies minimum valid numbers.
 * Smaller numbers are printed with leading zeroes. Bigger numbers are not affected.
 * Strings with more than precision characters are cut off.
 * Just as with width, an "*" can be used used instead of a number.
 * An integer value is then expected in parameters. When both width and precision
 * are specified using "*", the first parameter is used for width and the second one
 * for precision.
 *
 * TYPE:@n
 *  - "hh"  Signed or unsigned char.@n
 *  - "h"   Signed or usigned short.@n
 *  - ""    Signed or usigned int (default value).@n
 *  - "l"   Signed or usigned long int.@n
 *  - "ll"  Signed or usigned long long int.@n
 *  - "z"   __native (non-standard extension).@n
 *
 *
 * CONVERSION:@n
 *  - % Print percentile character itself.
 *
 *  - c Print single character.
 *
 *  - s Print zero terminated string. If a NULL value is passed as value, "(NULL)" is printed instead.
 *
 *  - P, p  Print value of a pointer. Void * value is expected and it is printed in hexadecimal notation with prefix
 *  (as with \%#X or \%#x for 32bit or \%#X / \%#x for 64bit long pointers).
 *
 *  - b Print value as unsigned binary number. Prefix is not printed by default. (Nonstandard extension.)
 *
 *  - o Print value as unsigned octal number. Prefix is not printed by default.
 *
 *  - d,i   Print signed decimal number. There is no difference between d and i conversion.
 *
 *  - u Print unsigned decimal number.
 *
 *  - X, x  Print hexadecimal number with upper- or lower-case. Prefix is not printed by default.
 *
 * All other characters from fmt except the formatting directives
 * are printed in verbatim.
 *
 * @param fmt Formatting NULL terminated string.
 * @return Number of printed characters or negative value on failure.
 */
int printf_core(const char *fmt, struct printf_spec *ps, va_list ap)
{
    int irqpri;
    int i = 0, j = 0; /**< i is index of currently processed char from fmt, j is index to the first not printed nonformating character */
    int end;
    int counter; /**< counter of printed characters */
    int retval; /**< used to store return values from called functions */
    char c;
    qualifier_t qualifier;  /* type of argument */
    int base;   /**< base in which will be parameter (numbers only) printed */
    __u64 number; /**< argument value */
    size_t  size; /**< byte size of integer parameter */
    int width, precision;
    __u64 flags;
   
    counter = 0;
   
    irqpri = interrupts_disable();
    spinlock_lock(&printflock);
 
    while ((c = fmt[i])) {
        /* control character */
        if (c == '%' ) {
            /* print common characters if any processed */ 
            if (i > j) {
                if ((retval = printf_putnchars(&fmt[j], (size_t)(i - j), ps)) == EOF) { /* error */
                    counter = -counter;
                    goto out;
                }
                counter += retval;
            }
       
            j = i;
            /* parse modifiers */
            flags = 0;
            end = 0;
           
            do {
                ++i;
                switch (c = fmt[i]) {
                    case '#': flags |= __PRINTF_FLAG_PREFIX; break;
                    case '-': flags |= __PRINTF_FLAG_LEFTALIGNED; break;
                    case '+': flags |= __PRINTF_FLAG_SHOWPLUS; break;
                    case ' ': flags |= __PRINTF_FLAG_SPACESIGN; break;
                    case '0': flags |= __PRINTF_FLAG_ZEROPADDED; break;
                    default: end = 1;
                }; 
               
            } while (end == 0);
           
            /* width & '*' operator */
            width = 0;
            if (isdigit(fmt[i])) {
                while (isdigit(fmt[i])) {
                    width *= 10;
                    width += fmt[i++] - '0';
                }
            } else if (fmt[i] == '*') {
                /* get width value from argument list*/
                i++;
                width = (int)va_arg(ap, int);
                if (width < 0) {
                    /* negative width means to set '-' flag */
                    width *= -1;
                    flags |= __PRINTF_FLAG_LEFTALIGNED;
                }
            }
           
            /* precision and '*' operator */   
            precision = 0;
            if (fmt[i] == '.') {
                ++i;
                if (isdigit(fmt[i])) {
                    while (isdigit(fmt[i])) {
                        precision *= 10;
                        precision += fmt[i++] - '0';
                    }
                } else if (fmt[i] == '*') {
                    /* get precision value from argument list*/
                    i++;
                    precision = (int)va_arg(ap, int);
                    if (precision < 0) {
                        /* negative precision means to ignore it */
                        precision = 0;
                    }
                }
            }
 
            switch (fmt[i++]) {
                /** TODO: unimplemented qualifiers:
                 * t ptrdiff_t - ISO C 99
                 */
                case 'h':   /* char or short */
                    qualifier = PrintfQualifierShort;
                    if (fmt[i] == 'h') {
                        i++;
                        qualifier = PrintfQualifierByte;
                    }
                    break;
                case 'l':   /* long or long long*/
                    qualifier = PrintfQualifierLong;
                    if (fmt[i] == 'l') {
                        i++;
                        qualifier = PrintfQualifierLongLong;
                    }
                    break;
                case 'z':   /* __native */
                    qualifier = PrintfQualifierNative;
                    break;
                default:
                    qualifier = PrintfQualifierInt; /* default type */
                    --i;
            }  
           
            base = 10;
 
            switch (c = fmt[i]) {
 
                /*
                * String and character conversions.
                */
                case 's':
                    if ((retval = print_string(va_arg(ap, char*), width, precision, flags, ps)) == EOF) {
                        counter = -counter;
                        goto out;
                    };
                   
                    counter += retval;
                    j = i + 1;
                    goto next_char;
                case 'c':
                    c = va_arg(ap, unsigned int);
                    if ((retval = print_char(c, width, flags, ps)) == EOF) {
                        counter = -counter;
                        goto out;
                    };
                   
                    counter += retval;
                    j = i + 1;
                    goto next_char;
 
                /*
                 * Integer values
                */
                case 'P': /* pointer */
                        flags |= __PRINTF_FLAG_BIGCHARS;
                case 'p':
                    flags |= __PRINTF_FLAG_PREFIX;
                    base = 16;
                    qualifier = PrintfQualifierPointer;
                    break; 
                case 'b':
                    base = 2;
                    break;
                case 'o':
                    base = 8;
                    break;
                case 'd':
                case 'i':
                    flags |= __PRINTF_FLAG_SIGNED;  
                case 'u':
                    break;
                case 'X':
                    flags |= __PRINTF_FLAG_BIGCHARS;
                case 'x':
                    base = 16;
                    break;
                /* percentile itself */
                case '%':
                    j = i;
                    goto next_char;
                /*
                * Bad formatting.
                */
                default:
                    /* Unknown format
                     *  now, the j is index of '%' so we will
                     * print whole bad format sequence
                     */
                    goto next_char;    
            }
       
       
        /* Print integers */
            /* print number */
            switch (qualifier) {
                case PrintfQualifierByte:
                    size = sizeof(unsigned char);
                    number = (__u64)va_arg(ap, unsigned int);
                    break;
                case PrintfQualifierShort:
                    size = sizeof(unsigned short);
                    number = (__u64)va_arg(ap, unsigned int);
                    break;
                case PrintfQualifierInt:
                    size = sizeof(unsigned int);
                    number = (__u64)va_arg(ap, unsigned int);
                    break;
                case PrintfQualifierLong:
                    size = sizeof(unsigned long);
                    number = (__u64)va_arg(ap, unsigned long);
                    break;
                case PrintfQualifierLongLong:
                    size = sizeof(unsigned long long);
                    number = (__u64)va_arg(ap, unsigned long long);
                    break;
                case PrintfQualifierPointer:
                    size = sizeof(void *);
                    number = (__u64)(unsigned long)va_arg(ap, void *);
                    break;
                case PrintfQualifierNative:
                    size = sizeof(__native);
                    number = (__u64)va_arg(ap, __native);
                    break;
                default: /* Unknown qualifier */
                    counter = -counter;
                    goto out;
            }
           
            if (flags & __PRINTF_FLAG_SIGNED) {
                if (number & (0x1 << (size*8 - 1))) {
                    flags |= __PRINTF_FLAG_NEGATIVE;
               
                    if (size == sizeof(__u64)) {
                        number = -((__s64)number);
                    } else {
                        number = ~number;
                        number &= (~((0xFFFFFFFFFFFFFFFFll) <<  (size * 8)));
                        number++;
                    }
                }
            }
 
            if ((retval = print_number(number, width, precision, base, flags, ps)) == EOF ) {
                counter = -counter;
                goto out;
            };
 
            counter += retval;
            j = i + 1;
        }  
next_char:
           
        ++i;
    }
   
    if (i > j) {
        if ((retval = printf_putnchars(&fmt[j], (__native)(i - j), ps)) == EOF) { /* error */
            counter = -counter;
            goto out;
           
        }
        counter += retval;
    }
 
out:
    spinlock_unlock(&printflock);
    interrupts_restore(irqpri);
   
    return counter;
}
 
 

Rev 1271	Rev 1273
1	/*	1	/*
2	* Copyright (C) 2001-2004 Jakub Jermar	2	* Copyright (C) 2001-2004 Jakub Jermar
3	* Copyright (C) 2006 Josef Cejka	3	* Copyright (C) 2006 Josef Cejka
4	* All rights reserved.	4	* All rights reserved.
5	*	5	*
6	* Redistribution and use in source and binary forms, with or without	6	* Redistribution and use in source and binary forms, with or without
7	* modification, are permitted provided that the following conditions	7	* modification, are permitted provided that the following conditions
8	* are met:	8	* are met:
9	*	9	*
10	* - Redistributions of source code must retain the above copyright	10	* - Redistributions of source code must retain the above copyright
11	* notice, this list of conditions and the following disclaimer.	11	* notice, this list of conditions and the following disclaimer.
12	* - Redistributions in binary form must reproduce the above copyright	12	* - Redistributions in binary form must reproduce the above copyright
13	* notice, this list of conditions and the following disclaimer in the	13	* notice, this list of conditions and the following disclaimer in the
14	* documentation and/or other materials provided with the distribution.	14	* documentation and/or other materials provided with the distribution.
15	* - The name of the author may not be used to endorse or promote products	15	* - The name of the author may not be used to endorse or promote products
16	* derived from this software without specific prior written permission.	16	* derived from this software without specific prior written permission.
17	*	17	*
18	* THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR	18	* THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR
19	* IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES	19	* IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
20	* OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.	20	* OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
21	* IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT,	21	* IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT,
22	* INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT	22	* INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
23	* NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,	23	* NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
24	* DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY	24	* DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
25	* THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT	25	* THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
26	* (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF	26	* (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
27	* THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.	27	* THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
28	*/	28	*/
29		29
30	/**	30	/**
31	* @file print.c	31	* @file print.c
32	* @brief Printing functions.	32	* @brief Printing functions.
33	*/	33	*/
34		34
35	#include <printf/printf_core.h>	35	#include <printf/printf_core.h>
36	#include <putchar.h>	36	#include <putchar.h>
37	#include <print.h>	37	#include <print.h>
38	#include <synch/spinlock.h>	38	#include <synch/spinlock.h>
39	#include <arch/arg.h>	39	#include <arch/arg.h>
40	#include <arch/asm.h>	40	#include <arch/asm.h>
41		41
42	#include <arch.h>	42	#include <arch.h>
43		43
44	SPINLOCK_INITIALIZE(printflock); /*< printf spinlock /	44	SPINLOCK_INITIALIZE(printflock); /*< printf spinlock /
45		45
46	#define __PRINTF_FLAG_PREFIX 0x00000001 /*< show prefixes 0x or 0/	46	#define __PRINTF_FLAG_PREFIX 0x00000001 /*< show prefixes 0x or 0/
47	#define __PRINTF_FLAG_SIGNED 0x00000002 /*< signed / unsigned number /	47	#define __PRINTF_FLAG_SIGNED 0x00000002 /*< signed / unsigned number /
48	#define __PRINTF_FLAG_ZEROPADDED 0x00000004 /*< print leading zeroes /	48	#define __PRINTF_FLAG_ZEROPADDED 0x00000004 /*< print leading zeroes /
49	#define __PRINTF_FLAG_LEFTALIGNED 0x00000010 /*< align to left /	49	#define __PRINTF_FLAG_LEFTALIGNED 0x00000010 /*< align to left /
50	#define __PRINTF_FLAG_SHOWPLUS 0x00000020 /*< always show + sign /	50	#define __PRINTF_FLAG_SHOWPLUS 0x00000020 /*< always show + sign /
51	#define __PRINTF_FLAG_SPACESIGN 0x00000040 /*< print space instead of plus /	51	#define __PRINTF_FLAG_SPACESIGN 0x00000040 /*< print space instead of plus /
52	#define __PRINTF_FLAG_BIGCHARS 0x00000080 /*< show big characters /	52	#define __PRINTF_FLAG_BIGCHARS 0x00000080 /*< show big characters /
53	#define __PRINTF_FLAG_NEGATIVE 0x00000100 /*< number has - sign /	53	#define __PRINTF_FLAG_NEGATIVE 0x00000100 /*< number has - sign /
54		54
55	#define PRINT_NUMBER_BUFFER_SIZE (64+5) /**< Buffer big enought for 64 bit number	55	#define PRINT_NUMBER_BUFFER_SIZE (64+5) /**< Buffer big enought for 64 bit number
56	* printed in base 2, sign, prefix and	56	* printed in base 2, sign, prefix and
57	* 0 to terminate string.. (last one is only for better testing	57	* 0 to terminate string.. (last one is only for better testing
58	* end of buffer by zero-filling subroutine)*/	58	* end of buffer by zero-filling subroutine)*/
59		59
60	/** Enumeration of possible arguments types.	60	/** Enumeration of possible arguments types.
61	*/	61	*/
62	typedef enum {	62	typedef enum {
63	PrintfQualifierByte = 0,	63	PrintfQualifierByte = 0,
64	PrintfQualifierShort,	64	PrintfQualifierShort,
65	PrintfQualifierInt,	65	PrintfQualifierInt,
66	PrintfQualifierLong,	66	PrintfQualifierLong,
67	PrintfQualifierLongLong,	67	PrintfQualifierLongLong,
68	PrintfQualifierNative,	68	PrintfQualifierNative,
69	PrintfQualifierPointer	69	PrintfQualifierPointer
70	} qualifier_t;	70	} qualifier_t;
71		71
72	static char digits_small[] = "0123456789abcdef"; /*< Small hexadecimal characters /	72	static char digits_small[] = "0123456789abcdef"; /*< Small hexadecimal characters /
73	static char digits_big[] = "0123456789ABCDEF"; /*< Big hexadecimal characters /	73	static char digits_big[] = "0123456789ABCDEF"; /*< Big hexadecimal characters /
74		74
75	/** Checks c for a digit.	75	/** Checks c for a digit.
76	* @param c One character.	76	* @param c One character.
77	* @return nonzero if c is from interval '0 to '9'.	77	* @return nonzero if c is from interval '0 to '9'.
78	*/	78	*/
79	static inline int isdigit(int c)	79	static inline int isdigit(int c)
80	{	80	{
81	return ((c >= '0' )&&( c <= '9'));	81	return ((c >= '0' )&&( c <= '9'));
82	}	82	}
83		83
84	/** Compute length of given zero terminated string.	84	/** Compute length of given zero terminated string.
85	* @param str Pointer to valid string.	85	* @param str Pointer to valid string.
86	* @return string length without trailing zero.	86	* @return string length without trailing zero.
87	*/	87	*/
88	static __native strlen(const char *str)	88	static __native strlen(const char *str)
89	{	89	{
90	__native counter = 0;	90	__native counter = 0;
91		91
92	while (str[counter] != 0) {	92	while (str[counter] != 0) {
93	counter++;	93	counter++;
94	}	94	}
95		95
96	return counter;	96	return counter;
97	}	97	}
98		98
99	/** Print count chars from buffer without adding newline	99	/** Print count chars from buffer without adding newline
100	* @param buf Buffer with size at least count bytes - NULL pointer NOT allowed!	100	* @param buf Buffer with size at least count bytes - NULL pointer NOT allowed!
101	* @param count	101	* @param count
102	* @param ps output method and its data	102	* @param ps output method and its data
103	* @return 0 on success, EOF on fail	103	* @return 0 on success, EOF on fail
104	*/	104	*/
105	static int printf_putnchars(const char * buf, size_t count, struct printf_spec *ps)	105	static int printf_putnchars(const char * buf, size_t count, struct printf_spec *ps)
106	{	106	{
107	if (ps->write((void *)buf, count, ps->data) == count) {	107	if (ps->write((void *)buf, count, ps->data) == count) {
108	return 0;	108	return 0;
109	}	109	}
110		110
111	return EOF;	111	return EOF;
112	}	112	}
113		113
114	/** Print string without added newline	114	/** Print string without added newline
115	* @param str string to print	115	* @param str string to print
116	* @param ps write function specification and support data	116	* @param ps write function specification and support data
117	* @return 0 on success or EOF on fail	117	* @return 0 on success or EOF on fail
118	*/	118	*/
119	static int printf_putstr(const char * str, struct printf_spec *ps)	119	static int printf_putstr(const char * str, struct printf_spec *ps)
120	{	120	{
121	size_t count;	121	size_t count;
122		122
123	if (str == NULL) {	123	if (str == NULL) {
124	return printf_putnchars("(NULL)", 6, ps);	124	return printf_putnchars("(NULL)", 6, ps);
125	}	125	}
126		126
127	count = strlen(str);	127	count = strlen(str);
128		128
129	if (ps->write((void *) str, count, ps->data) == count) {	129	if (ps->write((void *) str, count, ps->data) == count) {
130	return 0;	130	return 0;
131	}	131	}
132		132
133	return EOF;	133	return EOF;
134	}	134	}
135		135
136	/** Print one character to output	136	/** Print one character to output
137	* @param c one character	137	* @param c one character
138	* @param ps output method	138	* @param ps output method
139	* @return printed character or EOF	139	* @return printed character or EOF
140	*/	140	*/
141	static int printf_putchar(int c, struct printf_spec *ps)	141	static int printf_putchar(int c, struct printf_spec *ps)
142	{	142	{
143	unsigned char ch = c;	143	unsigned char ch = c;
144		144
145	if (ps->write((void *) &ch, 1, ps->data) == 1) {	145	if (ps->write((void *) &ch, 1, ps->data) == 1) {
146	return c;	146	return c;
147	}	147	}
148		148
149	return EOF;	149	return EOF;
150	}	150	}
151		151
152	/** Print one formatted character	152	/** Print one formatted character
153	* @param c character to print	153	* @param c character to print
154	* @param width	154	* @param width
155	* @param flags	155	* @param flags
156	* @return number of printed characters or EOF	156	* @return number of printed characters or EOF
157	*/	157	*/
158	static int print_char(char c, int width, __u64 flags, struct printf_spec *ps)	158	static int print_char(char c, int width, __u64 flags, struct printf_spec *ps)
159	{	159	{
160	int counter = 0;	160	int counter = 0;
161		161
162	if (!(flags & __PRINTF_FLAG_LEFTALIGNED)) {	162	if (!(flags & __PRINTF_FLAG_LEFTALIGNED)) {
163	while (--width > 0) { /* one space is consumed by character itself hence predecrement */	163	while (--width > 0) { /* one space is consumed by character itself hence predecrement */
164	/* FIXME: painful slow */	164	/* FIXME: painful slow */
165	printf_putchar(' ', ps);	165	printf_putchar(' ', ps);
166	++counter;	166	++counter;
167	}	167	}
168	}	168	}
169		169
170	if (printf_putchar(c, ps) == EOF) {	170	if (printf_putchar(c, ps) == EOF) {
171	return EOF;	171	return EOF;
172	}	172	}
173		173
174	while (--width > 0) { /* one space is consumed by character itself hence predecrement */	174	while (--width > 0) { /* one space is consumed by character itself hence predecrement */
175	printf_putchar(' ', ps);	175	printf_putchar(' ', ps);
176	++counter;	176	++counter;
177	}	177	}
178		178
179	return ++counter;	179	return ++counter;
180	}	180	}
181		181
182	/** Print one string	182	/** Print one string
183	* @param s string	183	* @param s string
184	* @param width	184	* @param width
185	* @param precision	185	* @param precision
186	* @param flags	186	* @param flags
187	* @return number of printed characters or EOF	187	* @return number of printed characters or EOF
188	*/	188	*/
189		189
190	static int print_string(char s, int width, int precision, __u64 flags, struct printf_spec ps)	190	static int print_string(char s, int width, int precision, __u64 flags, struct printf_spec ps)
191	{	191	{
192	int counter = 0;	192	int counter = 0;
193	size_t size;	193	size_t size;
194		194
195	if (s == NULL) {	195	if (s == NULL) {
196	return printf_putstr("(NULL)", ps);	196	return printf_putstr("(NULL)", ps);
197	}	197	}
198		198
199	size = strlen(s);	199	size = strlen(s);
200		200
201	/* print leading spaces */	201	/* print leading spaces */
202		202
203	if (precision == 0)	203	if (precision == 0)
204	precision = size;	204	precision = size;
205		205
206	width -= precision;	206	width -= precision;
207		207
208	if (!(flags & __PRINTF_FLAG_LEFTALIGNED)) {	208	if (!(flags & __PRINTF_FLAG_LEFTALIGNED)) {
209	while (width-- > 0) {	209	while (width-- > 0) {
210	printf_putchar(' ', ps);	210	printf_putchar(' ', ps);
211	counter++;	211	counter++;
212	}	212	}
213	}	213	}
214		214
215	while (precision > size) {	215	while (precision > size) {
216	precision--;	216	precision--;
217	printf_putchar(' ', ps);	217	printf_putchar(' ', ps);
218	++counter;	218	++counter;
219	}	219	}
220		220
221	if (printf_putnchars(s, precision, ps) == EOF) {	221	if (printf_putnchars(s, precision, ps) == EOF) {
222	return EOF;	222	return EOF;
223	}	223	}
224		224
225	counter += precision;	225	counter += precision;
226		226
227	while (width-- > 0) {	227	while (width-- > 0) {
228	printf_putchar(' ', ps);	228	printf_putchar(' ', ps);
229	++counter;	229	++counter;
230	}	230	}
231		231
232	return ++counter;	232	return ++counter;
233	}	233	}
234		234
235		235
236	/** Print number in given base	236	/** Print number in given base
237	*	237	*
238	* Print significant digits of a number in given	238	* Print significant digits of a number in given
239	* base.	239	* base.
240	*	240	*
241	* @param num Number to print.	241	* @param num Number to print.
242	* @param width	242	* @param width
243	* @param precision	243	* @param precision
244	* @param base Base to print the number in (should	244	* @param base Base to print the number in (should
245	* be in range 2 .. 16).	245	* be in range 2 .. 16).
246	* @param flags output modifiers	246	* @param flags output modifiers
247	* @return number of written characters or EOF	247	* @return number of written characters or EOF
248	*	248	*
249	*/	249	*/
250	static int print_number(__u64 num, int width, int precision, int base , __u64 flags, struct printf_spec *ps)	250	static int print_number(__u64 num, int width, int precision, int base , __u64 flags, struct printf_spec *ps)
251	{	251	{
252	char *digits = digits_small;	252	char *digits = digits_small;
253	char d[PRINT_NUMBER_BUFFER_SIZE]; /* this is good enough even for base == 2, prefix and sign */	253	char d[PRINT_NUMBER_BUFFER_SIZE]; /* this is good enough even for base == 2, prefix and sign */
254	char *ptr = &d[PRINT_NUMBER_BUFFER_SIZE - 1];	254	char *ptr = &d[PRINT_NUMBER_BUFFER_SIZE - 1];
255	int size = 0; /* size of number with all prefixes and signs */	255	int size = 0; /* size of number with all prefixes and signs */
256	int number_size; /* size of plain number */	256	int number_size; /* size of plain number */
257	int written = 0;	257	int written = 0;
258	char sgn;	258	char sgn;
259		259
260	if (flags & __PRINTF_FLAG_BIGCHARS)	260	if (flags & __PRINTF_FLAG_BIGCHARS)
261	digits = digits_big;	261	digits = digits_big;
262		262
263	ptr-- = 0; / Put zero at end of string */	263	ptr-- = 0; / Put zero at end of string */
264		264
265	if (num == 0) {	265	if (num == 0) {
266	*ptr-- = '0';	266	*ptr-- = '0';
267	size++;	267	size++;
268	} else {	268	} else {
269	do {	269	do {
270	*ptr-- = digits[num % base];	270	*ptr-- = digits[num % base];
271	size++;	271	size++;
272	} while (num /= base);	272	} while (num /= base);
273	}	273	}
274		274
275	number_size = size;	275	number_size = size;
276		276
277	/* Collect sum of all prefixes/signs/... to calculate padding and leading zeroes */	277	/* Collect sum of all prefixes/signs/... to calculate padding and leading zeroes */
278	if (flags & __PRINTF_FLAG_PREFIX) {	278	if (flags & __PRINTF_FLAG_PREFIX) {
279	switch(base) {	279	switch(base) {
280	case 2: /* Binary formating is not standard, but usefull */	280	case 2: /* Binary formating is not standard, but usefull */
281	size += 2;	281	size += 2;
282	break;	282	break;
283	case 8:	283	case 8:
284	size++;	284	size++;
285	break;	285	break;
286	case 16:	286	case 16:
287	size += 2;	287	size += 2;
288	break;	288	break;
289	}	289	}
290	}	290	}
291		291
292	sgn = 0;	292	sgn = 0;
293	if (flags & __PRINTF_FLAG_SIGNED) {	293	if (flags & __PRINTF_FLAG_SIGNED) {
294	if (flags & __PRINTF_FLAG_NEGATIVE) {	294	if (flags & __PRINTF_FLAG_NEGATIVE) {
295	sgn = '-';	295	sgn = '-';
296	size++;	296	size++;
297	} else if (flags & __PRINTF_FLAG_SHOWPLUS) {	297	} else if (flags & __PRINTF_FLAG_SHOWPLUS) {
298	sgn = '+';	298	sgn = '+';
299	size++;	299	size++;
300	} else if (flags & __PRINTF_FLAG_SPACESIGN) {	300	} else if (flags & __PRINTF_FLAG_SPACESIGN) {
301	sgn = ' ';	301	sgn = ' ';
302	size++;	302	size++;
303	}	303	}
304	}	304	}
305		305
306	if (flags & __PRINTF_FLAG_LEFTALIGNED) {	306	if (flags & __PRINTF_FLAG_LEFTALIGNED) {
307	flags &= ~__PRINTF_FLAG_ZEROPADDED;	307	flags &= ~__PRINTF_FLAG_ZEROPADDED;
308	}	308	}
309		309
310	/* if number is leftaligned or precision is specified then zeropadding is ignored */	310	/* if number is leftaligned or precision is specified then zeropadding is ignored */
311	if (flags & __PRINTF_FLAG_ZEROPADDED) {	311	if (flags & __PRINTF_FLAG_ZEROPADDED) {
312	if ((precision == 0) && (width > size)) {	312	if ((precision == 0) && (width > size)) {
313	precision = width - size + number_size;	313	precision = width - size + number_size;
314	}	314	}
315	}	315	}
316		316
317	/* print leading spaces */	317	/* print leading spaces */
318	if (number_size > precision) /* We must print whole number not only a part */	318	if (number_size > precision) /* We must print whole number not only a part */
319	precision = number_size;	319	precision = number_size;
320		320
321	width -= precision + size - number_size;	321	width -= precision + size - number_size;
322		322
323	if (!(flags & __PRINTF_FLAG_LEFTALIGNED)) {	323	if (!(flags & __PRINTF_FLAG_LEFTALIGNED)) {
324	while (width-- > 0) {	324	while (width-- > 0) {
325	printf_putchar(' ', ps);	325	printf_putchar(' ', ps);
326	written++;	326	written++;
327	}	327	}
328	}	328	}
329		329
330	/* print sign */	330	/* print sign */
331	if (sgn) {	331	if (sgn) {
332	printf_putchar(sgn, ps);	332	printf_putchar(sgn, ps);
333	written++;	333	written++;
334	}	334	}
335		335
336	/* print prefix */	336	/* print prefix */
337		337
338	if (flags & __PRINTF_FLAG_PREFIX) {	338	if (flags & __PRINTF_FLAG_PREFIX) {
339	switch(base) {	339	switch(base) {
340	case 2: /* Binary formating is not standard, but usefull */	340	case 2: /* Binary formating is not standard, but usefull */
341	printf_putchar('0', ps);	341	printf_putchar('0', ps);
342	if (flags & __PRINTF_FLAG_BIGCHARS) {	342	if (flags & __PRINTF_FLAG_BIGCHARS) {
343	printf_putchar('B', ps);	343	printf_putchar('B', ps);
344	} else {	344	} else {
345	printf_putchar('b', ps);	345	printf_putchar('b', ps);
346	}	346	}
347	written += 2;	347	written += 2;
348	break;	348	break;
349	case 8:	349	case 8:
350	printf_putchar('o', ps);	350	printf_putchar('o', ps);
351	written++;	351	written++;
352	break;	352	break;
353	case 16:	353	case 16:
354	printf_putchar('0', ps);	354	printf_putchar('0', ps);
355	if (flags & __PRINTF_FLAG_BIGCHARS) {	355	if (flags & __PRINTF_FLAG_BIGCHARS) {
356	printf_putchar('X', ps);	356	printf_putchar('X', ps);
357	} else {	357	} else {
358	printf_putchar('x', ps);	358	printf_putchar('x', ps);
359	}	359	}
360	written += 2;	360	written += 2;
361	break;	361	break;
362	}	362	}
363	}	363	}
364		364
365	/* print leading zeroes */	365	/* print leading zeroes */
366	precision -= number_size;	366	precision -= number_size;
367	while (precision-- > 0) {	367	while (precision-- > 0) {
368	printf_putchar('0', ps);	368	printf_putchar('0', ps);
369	written++;	369	written++;
370	}	370	}
371		371
372		372
373	/* print number itself */	373	/* print number itself */
374		374
375	written += printf_putstr(++ptr, ps);	375	written += printf_putstr(++ptr, ps);
376		376
377	/* print ending spaces */	377	/* print ending spaces */
378		378
379	while (width-- > 0) {	379	while (width-- > 0) {
380	printf_putchar(' ', ps);	380	printf_putchar(' ', ps);
381	written++;	381	written++;
382	}	382	}
383		383
384	return written;	384	return written;
385	}	385	}
386		386
387		387
388	/** Print formatted string.	388	/** Print formatted string.
389	*	389	*
390	* Print string formatted according to the fmt parameter	390	* Print string formatted according to the fmt parameter
391	* and variadic arguments. Each formatting directive	391	* and variadic arguments. Each formatting directive
392	* must have the following form:	392	* must have the following form:
393	*	393	*
394	* \% [ FLAGS ] [ WIDTH ] [ .PRECISION ] [ TYPE ] CONVERSION	394	* \% [ FLAGS ] [ WIDTH ] [ .PRECISION ] [ TYPE ] CONVERSION
395	*	395	*
396	* FLAGS:@n	396	* FLAGS:@n
397	* - "#" Force to print prefix.	397	* - "#" Force to print prefix.
398	* For conversion \%o the prefix is 0, for %x and \%X prefixes are 0x and 0X	398	* For conversion \%o the prefix is 0, for %x and \%X prefixes are 0x and 0X
399	* and for conversion \%b the prefix is 0b.	399	* and for conversion \%b the prefix is 0b.
400	*	400	*
401	* - "-" Align to left.	401	* - "-" Align to left.
402	*	402	*
403	* - "+" Print positive sign just as negative.	403	* - "+" Print positive sign just as negative.
404	*	404	*
405	* - " " If the printed number is positive and "+" flag is not set, print space in	405	* - " " If the printed number is positive and "+" flag is not set, print space in
406	* place of sign.	406	* place of sign.
407	*	407	*
408	* - "0" Print 0 as padding instead of spaces. Zeroes are placed between sign and the	408	* - "0" Print 0 as padding instead of spaces. Zeroes are placed between sign and the
409	* rest of the number. This flag is ignored if "-" flag is specified.	409	* rest of the number. This flag is ignored if "-" flag is specified.
410	*	410	*
411	* WIDTH:@n	411	* WIDTH:@n
412	* - Specify minimal width of printed argument. If it is bigger, width is ignored.	412	* - Specify minimal width of printed argument. If it is bigger, width is ignored.
413	* If width is specified with a "*" character instead of number, width is taken from	413	* If width is specified with a "*" character instead of number, width is taken from
414	* parameter list. And integer parameter is expected before parameter for processed	414	* parameter list. And integer parameter is expected before parameter for processed
415	* conversion specification. If this value is negative its absolute value is taken	415	* conversion specification. If this value is negative its absolute value is taken
416	* and the "-" flag is set.	416	* and the "-" flag is set.
417	*	417	*
418	* PRECISION:@n	418	* PRECISION:@n
419	* - Value precision. For numbers it specifies minimum valid numbers.	419	* - Value precision. For numbers it specifies minimum valid numbers.
420	* Smaller numbers are printed with leading zeroes. Bigger numbers are not affected.	420	* Smaller numbers are printed with leading zeroes. Bigger numbers are not affected.
421	* Strings with more than precision characters are cut off.	421	* Strings with more than precision characters are cut off.
422	* Just as with width, an "*" can be used used instead of a number.	422	* Just as with width, an "*" can be used used instead of a number.
423	* An integer value is then expected in parameters. When both width and precision	423	* An integer value is then expected in parameters. When both width and precision
424	* are specified using "*", the first parameter is used for width and the second one	424	* are specified using "*", the first parameter is used for width and the second one
425	* for precision.	425	* for precision.
426	*	426	*
427	* TYPE:@n	427	* TYPE:@n
428	* - "hh" Signed or unsigned char.@n	428	* - "hh" Signed or unsigned char.@n
429	* - "h" Signed or usigned short.@n	429	* - "h" Signed or usigned short.@n
430	* - "" Signed or usigned int (default value).@n	430	* - "" Signed or usigned int (default value).@n
431	* - "l" Signed or usigned long int.@n	431	* - "l" Signed or usigned long int.@n
432	* - "ll" Signed or usigned long long int.@n	432	* - "ll" Signed or usigned long long int.@n
433	* - "z" __native (non-standard extension).@n	433	* - "z" __native (non-standard extension).@n
434	*	434	*
435	*	435	*
436	* CONVERSION:@n	436	* CONVERSION:@n
437	* - % Print percentile character itself.	437	* - % Print percentile character itself.
438	*	438	*
439	* - c Print single character.	439	* - c Print single character.
440	*	440	*
441	* - s Print zero terminated string. If a NULL value is passed as value, "(NULL)" is printed instead.	441	* - s Print zero terminated string. If a NULL value is passed as value, "(NULL)" is printed instead.
442	*	442	*
443	* - P, p Print value of a pointer. Void * value is expected and it is printed in hexadecimal notation with prefix	443	* - P, p Print value of a pointer. Void * value is expected and it is printed in hexadecimal notation with prefix
444	* (as with \%#X or \%#x for 32bit or \%#X / \%#x for 64bit long pointers).	444	* (as with \%#X or \%#x for 32bit or \%#X / \%#x for 64bit long pointers).
445	*	445	*
446	* - b Print value as unsigned binary number. Prefix is not printed by default. (Nonstandard extension.)	446	* - b Print value as unsigned binary number. Prefix is not printed by default. (Nonstandard extension.)
447	*	447	*
448	* - o Print value as unsigned octal number. Prefix is not printed by default.	448	* - o Print value as unsigned octal number. Prefix is not printed by default.
449	*	449	*
450	* - d,i Print signed decimal number. There is no difference between d and i conversion.	450	* - d,i Print signed decimal number. There is no difference between d and i conversion.
451	*	451	*
452	* - u Print unsigned decimal number.	452	* - u Print unsigned decimal number.
453	*	453	*
454	* - X, x Print hexadecimal number with upper- or lower-case. Prefix is not printed by default.	454	* - X, x Print hexadecimal number with upper- or lower-case. Prefix is not printed by default.
455	*	455	*
456	* All other characters from fmt except the formatting directives	456	* All other characters from fmt except the formatting directives
457	* are printed in verbatim.	457	* are printed in verbatim.
458	*	458	*
459	* @param fmt Formatting NULL terminated string.	459	* @param fmt Formatting NULL terminated string.
460	* @return Number of printed characters or negative value on failure.	460	* @return Number of printed characters or negative value on failure.
461	*/	461	*/
462	int printf_core(const char fmt, struct printf_spec ps, va_list ap)	462	int printf_core(const char fmt, struct printf_spec ps, va_list ap)
463	{	463	{
464	int irqpri;	464	int irqpri;
465	int i = 0, j = 0; /* i is index of currently processed char from fmt, j is index to the first not printed nonformating character */	465	int i = 0, j = 0; /*< i is index of currently processed char from fmt, j is index to the first not printed nonformating character /
466	int end;	466	int end;
467	int counter; /* counter of printed characters */	467	int counter; /*< counter of printed characters /
468	int retval; /* used to store return values from called functions */	468	int retval; /*< used to store return values from called functions /
469	char c;	469	char c;
470	qualifier_t qualifier; /* type of argument */	470	qualifier_t qualifier; /* type of argument */
471	int base; /* base in which will be parameter (numbers only) printed */	471	int base; /*< base in which will be parameter (numbers only) printed /
472	__u64 number; /* argument value */	472	__u64 number; /*< argument value /
473	size_t size; /* byte size of integer parameter */	473	size_t size; /*< byte size of integer parameter /
474	int width, precision;	474	int width, precision;
475	__u64 flags;	475	__u64 flags;
476		476
477	counter = 0;	477	counter = 0;
478		478
479	irqpri = interrupts_disable();	479	irqpri = interrupts_disable();
480	spinlock_lock(&printflock);	480	spinlock_lock(&printflock);
481		481
482	while ((c = fmt[i])) {	482	while ((c = fmt[i])) {
483	/* control character */	483	/* control character */
484	if (c == '%' ) {	484	if (c == '%' ) {
485	/* print common characters if any processed */	485	/* print common characters if any processed */
486	if (i > j) {	486	if (i > j) {
487	if ((retval = printf_putnchars(&fmt[j], (size_t)(i - j), ps)) == EOF) { /* error */	487	if ((retval = printf_putnchars(&fmt[j], (size_t)(i - j), ps)) == EOF) { /* error */
488	counter = -counter;	488	counter = -counter;
489	goto out;	489	goto out;
490	}	490	}
491	counter += retval;	491	counter += retval;
492	}	492	}
493		493
494	j = i;	494	j = i;
495	/* parse modifiers */	495	/* parse modifiers */
496	flags = 0;	496	flags = 0;
497	end = 0;	497	end = 0;
498		498
499	do {	499	do {
500	++i;	500	++i;

Subversion Repositories HelenOS-historic

(root)/kernel/trunk/generic/src/printf/printf_core.c @ 1780 – Rev 1271 → 1273