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


/*
 * Copyright (c) 2001-2004 Jakub Jermar
 * Copyright (c) 2006 Josef Cejka
 * Copyright (c) 2009 Martin Decky
 * 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.
 */
 
/** @addtogroup generic
 * @{
 */
/**
 * @file
 * @brief Printing functions.
 */
 
#include <printf/printf_core.h>
#include <print.h>
#include <arch/arg.h>
#include <macros.h>
#include <string.h>
#include <arch.h>
 
/** show prefixes 0x or 0 */
#define __PRINTF_FLAG_PREFIX       0x00000001
/** signed / unsigned number */
#define __PRINTF_FLAG_SIGNED       0x00000002
/** print leading zeroes */
#define __PRINTF_FLAG_ZEROPADDED   0x00000004
/** align to left */
#define __PRINTF_FLAG_LEFTALIGNED  0x00000010
/** always show + sign */
#define __PRINTF_FLAG_SHOWPLUS     0x00000020
/** print space instead of plus */
#define __PRINTF_FLAG_SPACESIGN    0x00000040
/** show big characters */
#define __PRINTF_FLAG_BIGCHARS     0x00000080
/** number has - sign */
#define __PRINTF_FLAG_NEGATIVE     0x00000100
 
/**
 * Buffer big enough 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)
 */
#define PRINT_NUMBER_BUFFER_SIZE  (64 + 5)
 
/** Enumeration of possible arguments types.
 */
typedef enum {
    PrintfQualifierByte = 0,
    PrintfQualifierShort,
    PrintfQualifierInt,
    PrintfQualifierLong,
    PrintfQualifierLongLong,
    PrintfQualifierPointer
} qualifier_t;
 
static char nullstr[] = "(NULL)";
static char digits_small[] = "0123456789abcdef";
static char digits_big[] = "0123456789ABCDEF";
 
/** Print one or more UTF-8 characters without adding newline.
 *
 * @param buf  Buffer holding UTF-8 characters with size of
 *             at least size bytes. NULL is not allowed!
 * @param size Size of the buffer in bytes.
 * @param ps   Output method and its data.
 *
 * @return Number of UTF-8 characters printed.
 *
 */
static int printf_putnchars_utf8(const char *buf, size_t size,
    printf_spec_t *ps)
{
    return ps->write_utf8((void *) buf, size, ps->data);
}
 
/** Print one or more UTF-32 characters without adding newline.
 *
 * @param buf  Buffer holding UTF-32 characters with size of
 *             at least size bytes. NULL is not allowed!
 * @param size Size of the buffer in bytes.
 * @param ps   Output method and its data.
 *
 * @return Number of UTF-32 characters printed.
 *
 */
static int printf_putnchars_utf32(const wchar_t *buf, size_t size,
    printf_spec_t *ps)
{
    return ps->write_utf32((void *) buf, size, ps->data);
}
 
/** Print UTF-8 string without adding a newline.
 *
 * @param str UTF-8 string to print.
 * @param ps  Write function specification and support data.
 *
 * @return Number of UTF-8 characters printed.
 *
 */
static int printf_putstr(const char *str, printf_spec_t *ps)
{
    if (str == NULL)
        return printf_putnchars_utf8(nullstr, strlen(nullstr), ps);
   
    return ps->write_utf8((void *) str, strlen(str), ps->data);
}
 
/** Print one ASCII character.
 *
 * @param c  ASCII character to be printed.
 * @param ps Output method.
 *
 * @return Number of characters printed.
 *
 */
static int printf_putchar(const char ch, printf_spec_t *ps)
{
    if (!ascii_check(ch))
        return ps->write_utf8((void *) &invalch, 1, ps->data);
   
    return ps->write_utf8(&ch, 1, ps->data);
}
 
/** Print one UTF-32 character.
 *
 * @param c  UTF-32 character to be printed.
 * @param ps Output method.
 *
 * @return Number of characters printed.
 *
 */
static int printf_putwchar(const wchar_t ch, printf_spec_t *ps)
{
    if (!unicode_check(ch))
        return ps->write_utf8((void *) &invalch, 1, ps->data);
   
    return ps->write_utf32(&ch, 1, ps->data);
}
 
/** Print one formatted ASCII character.
 *
 * @param ch    Character to print.
 * @param width Width modifier.
 * @param flags Flags that change the way the character is printed.
 *
 * @return Number of characters printed, negative value on failure.
 *
 */
static int print_char(const char ch, int width, uint32_t flags, printf_spec_t *ps)
{
    count_t counter = 0;
    if (!(flags & __PRINTF_FLAG_LEFTALIGNED)) {
        while (--width > 0) {
            /*
             * One space is consumed by the character itself, hence
             * the predecrement.
             */
            if (printf_putchar(' ', ps) > 0)
                counter++;
        }
    }
   
    if (printf_putchar(ch, ps) > 0)
        counter++;
   
    while (--width > 0) {
        /*
         * One space is consumed by the character itself, hence
         * the predecrement.
         */
        if (printf_putchar(' ', ps) > 0)
            counter++;
    }
   
    return (int) (counter + 1);
}
 
/** Print one formatted UTF-32 character.
 *
 * @param ch    Character to print.
 * @param width Width modifier.
 * @param flags Flags that change the way the character is printed.
 *
 * @return Number of characters printed, negative value on failure.
 *
 */
static int print_wchar(const wchar_t ch, int width, uint32_t flags, printf_spec_t *ps)
{
    count_t counter = 0;
    if (!(flags & __PRINTF_FLAG_LEFTALIGNED)) {
        while (--width > 0) {
            /*
             * One space is consumed by the character itself, hence
             * the predecrement.
             */
            if (printf_putchar(' ', ps) > 0)
                counter++;
        }
    }
   
    if (printf_putwchar(ch, ps) > 0)
        counter++;
   
    while (--width > 0) {
        /*
         * One space is consumed by the character itself, hence
         * the predecrement.
         */
        if (printf_putchar(' ', ps) > 0)
            counter++;
    }
   
    return (int) (counter + 1);
}
 
/** Print UTF-8 string.
 *
 * @param str       UTF-8 string to be printed.
 * @param width     Width modifier.
 * @param precision Precision modifier.
 * @param flags     Flags that modify the way the string is printed.
 *
 * @return Number of UTF-8 characters printed, negative value on failure.
 */
static int print_utf8(char *str, int width, unsigned int precision,
    uint32_t flags, printf_spec_t *ps)
{
    if (str == NULL)
        return printf_putstr(nullstr, ps);
   
    /* Print leading spaces */
    size_t size = strlen_utf8(str);
    if (precision == 0)
        precision = size;
   
    count_t counter = 0;
    width -= precision;
    if (!(flags & __PRINTF_FLAG_LEFTALIGNED)) {
        while (width-- > 0) {
            if (printf_putchar(' ', ps) == 1)
                counter++;
        }
    }
   
    int retval;
    size_t bytes = utf8_count_bytes(str, min(size, precision));
    if ((retval = printf_putnchars_utf8(str, bytes, ps)) < 0)
        return -counter;
   
    counter += retval;
   
    while (width-- > 0) {
        if (printf_putchar(' ', ps) == 1)
            counter++;
    }
   
    return ((int) counter);
}
 
/** Print UTF-32 string.
 *
 * @param str       UTF-32 string to be printed.
 * @param width     Width modifier.
 * @param precision Precision modifier.
 * @param flags     Flags that modify the way the string is printed.
 *
 * @return Number of UTF-32 characters printed, negative value on failure.
 */
static int print_utf32(wchar_t *str, int width, unsigned int precision,
    uint32_t flags, printf_spec_t *ps)
{
    if (str == NULL)
        return printf_putstr(nullstr, ps);
   
    /* Print leading spaces */
    size_t size = strlen_utf32(str);
    if (precision == 0)
        precision = size;
   
    count_t counter = 0;
    width -= precision;
    if (!(flags & __PRINTF_FLAG_LEFTALIGNED)) {
        while (width-- > 0) {
            if (printf_putchar(' ', ps) == 1)
                counter++;
        }
    }
   
    int retval;
    size_t bytes = min(size, precision) * sizeof(wchar_t);
    if ((retval = printf_putnchars_utf32(str, bytes, ps)) < 0)
        return -counter;
   
    counter += retval;
   
    while (width-- > 0) {
        if (printf_putchar(' ', ps) == 1)
            counter++;
    }
   
    return ((int) counter);
}
 
/** Print a number in a given base.
 *
 * Print significant digits of a number in given base.
 *
 * @param num       Number to print.
 * @param width     Width modifier.
 * @param precision Precision modifier.
 * @param base      Base to print the number in (must be between 2 and 16).
 * @param flags     Flags that modify the way the number is printed.
 *
 * @return Number of characters printed.
 *
 */
static int print_number(uint64_t num, int width, int precision, int base,
    uint32_t flags, printf_spec_t *ps)
{
    char *digits;
    if (flags & __PRINTF_FLAG_BIGCHARS)
        digits = digits_big;
    else
        digits = digits_small;
   
    char data[PRINT_NUMBER_BUFFER_SIZE];
    char *ptr = &data[PRINT_NUMBER_BUFFER_SIZE - 1];
   
    /* Size of number with all prefixes and signs */
    int size = 0;
   
    /* Put zero at end of string */
    *ptr-- = 0;
   
    if (num == 0) {
        *ptr-- = '0';
        size++;
    } else {
        do {
            *ptr-- = digits[num % base];
            size++;
        } while (num /= base);
    }
   
    /* Size of plain number */
    int number_size = size;
   
    /*
     * Collect the sum of all prefixes/signs/etc. 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;
        }
    }
   
    char 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 the number is left-aligned or precision is specified then
     * padding with zeros is ignored.
     */
    if (flags & __PRINTF_FLAG_ZEROPADDED) {
        if ((precision == 0) && (width > size))
            precision = width - size + number_size;
    }
   
    /* Print leading spaces */
    if (number_size > precision) {
        /* Print the whole number, not only a part */
        precision = number_size;
    }
   
    width -= precision + size - number_size;
    count_t counter = 0;
   
    if (!(flags & __PRINTF_FLAG_LEFTALIGNED)) {
        while (width-- > 0) {
            if (printf_putchar(' ', ps) == 1)
                counter++;
        }
    }
   
    /* Print sign */
    if (sgn) {
        if (printf_putchar(sgn, ps) == 1)
            counter++;
    }
   
    /* Print prefix */
    if (flags & __PRINTF_FLAG_PREFIX) {
        switch(base) {
        case 2:
            /* Binary formating is not standard, but usefull */
            if (printf_putchar('0', ps) == 1)
                counter++;
            if (flags & __PRINTF_FLAG_BIGCHARS) {
                if (printf_putchar('B', ps) == 1)
                    counter++;
            } else {
                if (printf_putchar('b', ps) == 1)
                    counter++;
            }
            break;
        case 8:
            if (printf_putchar('o', ps) == 1)
                counter++;
            break;
        case 16:
            if (printf_putchar('0', ps) == 1)
                counter++;
            if (flags & __PRINTF_FLAG_BIGCHARS) {
                if (printf_putchar('X', ps) == 1)
                    counter++;
            } else {
                if (printf_putchar('x', ps) == 1)
                    counter++;
            }
            break;
        }
    }
   
    /* Print leading zeroes */
    precision -= number_size;
    while (precision-- > 0) {
        if (printf_putchar('0', ps) == 1)
            counter++;
    }
   
    /* Print the number itself */
    int retval;
    if ((retval = printf_putstr(++ptr, ps)) > 0)
        counter += retval;
   
    /* Print tailing spaces */
   
    while (width-- > 0) {
        if (printf_putchar(' ', ps) == 1)
            counter++;
    }
   
    return ((int) counter);
}
 
/** 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 \%o conversion, 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 the minimal width of a 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 unsigned short.@n
 *  - ""   Signed or unsigned int (default value).@n
 *  - "l"  Signed or unsigned long int.@n
 *         If conversion is "c", the character is wchar_t (UTF-32).@n
 *         If conversion is "s", the string is wchar_t * (UTF-32).@n
 *  - "ll" Signed or unsigned long long int.@n
 *
 * CONVERSION:@n
 *  - % Print percentile character itself.
 *
 *  - c Print single character. The character is expected to be plain
 *      ASCII (e.g. only values 0 .. 127 are valid).@n
 *      If type is "l", then the character is expected to be UTF-32
 *      (e.g. values 0 .. 0x10ffff are valid).
 *
 *  - s Print zero terminated string. If a NULL value is passed as
 *      value, "(NULL)" is printed instead.@n
 *      The string is expected to be correctly encoded UTF-8 (or plain
 *      ASCII, which is a subset of UTF-8).@n
 *      If type is "l", then the string is expected to be correctly
 *      encoded UTF-32.
 *
 *  - P, p Print value of a pointer. Void * value is expected and it is
 *         printed in hexadecimal notation with prefix (as with \%#X / \%#x
 *         for 32-bit or \%#X / \%#x for 64-bit 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 (UTF-8 or plain ASCII).
 *
 * @return Number of UTF-8 characters printed, negative value on failure.
 *
 */
int printf_core(const char *fmt, printf_spec_t *ps, va_list ap)
{
    index_t i = 0;  /* Index of the currently processed character from fmt */
    index_t j = 0;  /* Index to the first not printed nonformating character */
   
    wchar_t uc;           /* Current UTF-32 character decoded from fmt */
    count_t counter = 0;  /* Number of UTF-8 characters printed */
    int retval;           /* Return values from nested functions */
   
    while ((uc = utf8_decode(fmt, &i, UTF8_NO_LIMIT)) != 0) {
        /* Control character */
        if (uc == '%') {
            /* Print common characters if any processed */
            if (i > j) {
                if ((retval = printf_putnchars_utf8(&fmt[j], i - j, ps)) < 0) {
                    /* Error */
                    counter = -counter;
                    goto out;
                }
                counter += retval;
            }
           
            j = i;
           
            /* Parse modifiers */
            uint32_t flags = 0;
            bool end = false;
           
            do {
                i++;
                uc = utf8_decode(fmt, &i, UTF8_NO_LIMIT);
                switch (uc) {
                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 = true;
                };
            } while (!end);
           
            /* Width & '*' operator */
            int width = 0;
            if (isdigit(uc)) {
                while ((uc = utf8_decode(fmt, &i, UTF8_NO_LIMIT)) != 0) {
                    if (!isdigit(uc))
                        break;
                   
                    width *= 10;
                    width += uc - '0';
                    i++;
                }
            } else if (uc == '*') {
                /* Get width value from argument list */
                i++;
                uc = utf8_decode(fmt, &i, UTF8_NO_LIMIT);
                width = (int) va_arg(ap, int);
                if (width < 0) {
                    /* Negative width sets '-' flag */
                    width *= -1;
                    flags |= __PRINTF_FLAG_LEFTALIGNED;
                }
            }
           
            /* Precision and '*' operator */
            int precision = 0;
            if (uc == '.') {
                i++;
                uc = utf8_decode(fmt, &i, UTF8_NO_LIMIT);
                if (isdigit(uc)) {
                    while ((uc = utf8_decode(fmt, &i, UTF8_NO_LIMIT)) != 0) {
                        if (!isdigit(uc))
                            break;
                       
                        precision *= 10;
                        precision += uc - '0';
                        i++;
                    }
                } else if (fmt[i] == '*') {
                    /* Get precision value from the argument list */
                    i++;
                    uc = utf8_decode(fmt, &i, UTF8_NO_LIMIT);
                    precision = (int) va_arg(ap, int);
                    if (precision < 0) {
                        /* Ignore negative precision */
                        precision = 0;
                    }
                }
            }
           
            qualifier_t qualifier;
           
            switch (uc) {
            /** @todo Unimplemented qualifiers:
             *        t ptrdiff_t - ISO C 99
             */
            case 'h':
                /* Char or short */
                qualifier = PrintfQualifierShort;
                i++;
                uc = utf8_decode(fmt, &i, UTF8_NO_LIMIT);
                if (uc == 'h') {
                    i++;
                    uc = utf8_decode(fmt, &i, UTF8_NO_LIMIT);
                    qualifier = PrintfQualifierByte;
                }
                break;
            case 'l':
                /* Long or long long */
                qualifier = PrintfQualifierLong;
                i++;
                uc = utf8_decode(fmt, &i, UTF8_NO_LIMIT);
                if (uc == 'l') {
                    i++;
                    uc = utf8_decode(fmt, &i, UTF8_NO_LIMIT);
                    qualifier = PrintfQualifierLongLong;
                }
                break;
            default:
                /* Default type */
                qualifier = PrintfQualifierInt;
            }
           
            unsigned int base = 10;
           
            switch (uc) {
            /*
             * String and character conversions.
             */
            case 's':
                if (qualifier == PrintfQualifierLong)
                    retval = print_utf32(va_arg(ap, wchar_t *), width, precision, flags, ps);
                else
                    retval = print_utf8(va_arg(ap, char *), width, precision, flags, ps);
               
                if (retval < 0) {
                    counter = -counter;
                    goto out;
                }
               
                counter += retval;
                j = i + 1;
                goto next_char;
            case 'c':
                if (qualifier == PrintfQualifierLong)
                    retval = print_wchar(va_arg(ap, wchar_t), width, flags, ps);
                else
                    retval = print_char(va_arg(ap, unsigned int), width, flags, ps);
               
                if (retval < 0) {
                    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, j is the index of '%'
                 * so we will print whole bad format sequence.
                 */
                goto next_char;
            }
           
            /* Print integers */
            size_t size;
            uint64_t number;
            switch (qualifier) {
            case PrintfQualifierByte:
                size = sizeof(unsigned char);
                number = (uint64_t) va_arg(ap, unsigned int);
                break;
            case PrintfQualifierShort:
                size = sizeof(unsigned short);
                number = (uint64_t) va_arg(ap, unsigned int);
                break;
            case PrintfQualifierInt:
                size = sizeof(unsigned int);
                number = (uint64_t) va_arg(ap, unsigned int);
                break;
            case PrintfQualifierLong:
                size = sizeof(unsigned long);
                number = (uint64_t) va_arg(ap, unsigned long);
                break;
            case PrintfQualifierLongLong:
                size = sizeof(unsigned long long);
                number = (uint64_t) va_arg(ap, unsigned long long);
                break;
            case PrintfQualifierPointer:
                size = sizeof(void *);
                number = (uint64_t) (unsigned long) va_arg(ap, void *);
                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(uint64_t)) {
                        number = -((int64_t) number);
                    } else {
                        number = ~number;
                        number &=
                            ~(0xFFFFFFFFFFFFFFFFll <<
                            (size * 8));
                        number++;
                    }
                }
            }
           
            if ((retval = print_number(number, width, precision,
                base, flags, ps)) < 0) {
                counter = -counter;
                goto out;
            }
           
            counter += retval;
            j = i + 1;
        }
next_char:
       
        i++;
    }
   
    if (i > j) {
        if ((retval = printf_putnchars_utf8(&fmt[j], i - j, ps)) < 0) {
            /* Error */
            counter = -counter;
            goto out;
        }
        counter += retval;
    }
   
out:
    return ((int) counter);
}
 
/** @}
 */
 

Rev 4180	Rev 4183
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	* Copyright (c) 2009 Martin Decky	4	* Copyright (c) 2009 Martin Decky
5	* All rights reserved.	5	* All rights reserved.
6	*	6	*
7	* Redistribution and use in source and binary forms, with or without	7	* Redistribution and use in source and binary forms, with or without
8	* modification, are permitted provided that the following conditions	8	* modification, are permitted provided that the following conditions
9	* are met:	9	* are met:
10	*	10	*
11	* - Redistributions of source code must retain the above copyright	11	* - Redistributions of source code must retain the above copyright
12	* notice, this list of conditions and the following disclaimer.	12	* notice, this list of conditions and the following disclaimer.
13	* - Redistributions in binary form must reproduce the above copyright	13	* - Redistributions in binary form must reproduce the above copyright
14	* notice, this list of conditions and the following disclaimer in the	14	* notice, this list of conditions and the following disclaimer in the
15	* documentation and/or other materials provided with the distribution.	15	* documentation and/or other materials provided with the distribution.
16	* - The name of the author may not be used to endorse or promote products	16	* - The name of the author may not be used to endorse or promote products
17	* derived from this software without specific prior written permission.	17	* derived from this software without specific prior written permission.
18	*	18	*
19	* THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR	19	* THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR
20	* IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES	20	* IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
21	* OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.	21	* OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
22	* IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT,	22	* IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT,
23	* INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT	23	* INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
24	* NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,	24	* NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
25	* DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY	25	* DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
26	* THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT	26	* THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
27	* (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF	27	* (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
28	* THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.	28	* THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
29	*/	29	*/
30		30
31	/** @addtogroup generic	31	/** @addtogroup generic
32	* @{	32	* @{
33	*/	33	*/
34	/**	34	/**
35	* @file	35	* @file
36	* @brief Printing functions.	36	* @brief Printing functions.
37	*/	37	*/
38		38
39	#include <printf/printf_core.h>	39	#include <printf/printf_core.h>
40	#include <print.h>	40	#include <print.h>
41	#include <arch/arg.h>	41	#include <arch/arg.h>
42	#include <macros.h>	42	#include <macros.h>
43	#include <string.h>	43	#include <string.h>
44	#include <arch.h>	44	#include <arch.h>
45		45
46	/** show prefixes 0x or 0 */	46	/** show prefixes 0x or 0 */
47	#define __PRINTF_FLAG_PREFIX 0x00000001	47	#define __PRINTF_FLAG_PREFIX 0x00000001
48	/** signed / unsigned number */	48	/** signed / unsigned number */
49	#define __PRINTF_FLAG_SIGNED 0x00000002	49	#define __PRINTF_FLAG_SIGNED 0x00000002
50	/** print leading zeroes */	50	/** print leading zeroes */
51	#define __PRINTF_FLAG_ZEROPADDED 0x00000004	51	#define __PRINTF_FLAG_ZEROPADDED 0x00000004
52	/** align to left */	52	/** align to left */
53	#define __PRINTF_FLAG_LEFTALIGNED 0x00000010	53	#define __PRINTF_FLAG_LEFTALIGNED 0x00000010
54	/** always show + sign */	54	/** always show + sign */
55	#define __PRINTF_FLAG_SHOWPLUS 0x00000020	55	#define __PRINTF_FLAG_SHOWPLUS 0x00000020
56	/** print space instead of plus */	56	/** print space instead of plus */
57	#define __PRINTF_FLAG_SPACESIGN 0x00000040	57	#define __PRINTF_FLAG_SPACESIGN 0x00000040
58	/** show big characters */	58	/** show big characters */
59	#define __PRINTF_FLAG_BIGCHARS 0x00000080	59	#define __PRINTF_FLAG_BIGCHARS 0x00000080
60	/** number has - sign */	60	/** number has - sign */
61	#define __PRINTF_FLAG_NEGATIVE 0x00000100	61	#define __PRINTF_FLAG_NEGATIVE 0x00000100
62		62
63	/**	63	/**
64	* Buffer big enough for 64-bit number printed in base 2, sign, prefix and 0	64	* Buffer big enough for 64-bit number printed in base 2, sign, prefix and 0
65	* to terminate string... (last one is only for better testing end of buffer by	65	* to terminate string... (last one is only for better testing end of buffer by
66	* zero-filling subroutine)	66	* zero-filling subroutine)
67	*/	67	*/
68	#define PRINT_NUMBER_BUFFER_SIZE (64 + 5)	68	#define PRINT_NUMBER_BUFFER_SIZE (64 + 5)
69		69
70	/** Enumeration of possible arguments types.	70	/** Enumeration of possible arguments types.
71	*/	71	*/
72	typedef enum {	72	typedef enum {
73	PrintfQualifierByte = 0,	73	PrintfQualifierByte = 0,
74	PrintfQualifierShort,	74	PrintfQualifierShort,
75	PrintfQualifierInt,	75	PrintfQualifierInt,
76	PrintfQualifierLong,	76	PrintfQualifierLong,
77	PrintfQualifierLongLong,	77	PrintfQualifierLongLong,
78	PrintfQualifierPointer	78	PrintfQualifierPointer
79	} qualifier_t;	79	} qualifier_t;
80		80
81	static char nullstr[] = "(NULL)";	81	static char nullstr[] = "(NULL)";
82	static char digits_small[] = "0123456789abcdef";	82	static char digits_small[] = "0123456789abcdef";
83	static char digits_big[] = "0123456789ABCDEF";	83	static char digits_big[] = "0123456789ABCDEF";
84		84
85	/** Print one or more UTF-8 characters without adding newline.	85	/** Print one or more UTF-8 characters without adding newline.
86	*	86	*
87	* @param buf Buffer holding UTF-8 characters with size of	87	* @param buf Buffer holding UTF-8 characters with size of
88	* at least size bytes. NULL is not allowed!	88	* at least size bytes. NULL is not allowed!
89	* @param size Size of the buffer in bytes.	89	* @param size Size of the buffer in bytes.
90	* @param ps Output method and its data.	90	* @param ps Output method and its data.
91	*	91	*
92	* @return Number of UTF-8 characters printed.	92	* @return Number of UTF-8 characters printed.
93	*	93	*
94	*/	94	*/
95	static int printf_putnchars_utf8(const char *buf, size_t size,	95	static int printf_putnchars_utf8(const char *buf, size_t size,
96	printf_spec_t *ps)	96	printf_spec_t *ps)
97	{	97	{
98	return ps->write_utf8((void *) buf, size, ps->data);	98	return ps->write_utf8((void *) buf, size, ps->data);
99	}	99	}
100		100
101	/** Print one or more UTF-32 characters without adding newline.	101	/** Print one or more UTF-32 characters without adding newline.
102	*	102	*
103	* @param buf Buffer holding UTF-32 characters with size of	103	* @param buf Buffer holding UTF-32 characters with size of
104	* at least size bytes. NULL is not allowed!	104	* at least size bytes. NULL is not allowed!
105	* @param size Size of the buffer in bytes.	105	* @param size Size of the buffer in bytes.
106	* @param ps Output method and its data.	106	* @param ps Output method and its data.
107	*	107	*
108	* @return Number of UTF-32 characters printed.	108	* @return Number of UTF-32 characters printed.
109	*	109	*
110	*/	110	*/
111	static int printf_putnchars_utf32(const wchar_t *buf, size_t size,	111	static int printf_putnchars_utf32(const wchar_t *buf, size_t size,
112	printf_spec_t *ps)	112	printf_spec_t *ps)
113	{	113	{
114	return ps->write_utf32((void *) buf, size, ps->data);	114	return ps->write_utf32((void *) buf, size, ps->data);
115	}	115	}
116		116
117	/** Print UTF-8 string without adding a newline.	117	/** Print UTF-8 string without adding a newline.
118	*	118	*
119	* @param str UTF-8 string to print.	119	* @param str UTF-8 string to print.
120	* @param ps Write function specification and support data.	120	* @param ps Write function specification and support data.
121	*	121	*
122	* @return Number of UTF-8 characters printed.	122	* @return Number of UTF-8 characters printed.
123	*	123	*
124	*/	124	*/
125	static int printf_putstr(const char str, printf_spec_t ps)	125	static int printf_putstr(const char str, printf_spec_t ps)
126	{	126	{
127	if (str == NULL)	127	if (str == NULL)
128	return printf_putnchars_utf8(nullstr, strlen(nullstr), ps);	128	return printf_putnchars_utf8(nullstr, strlen(nullstr), ps);
129		129
130	return ps->write_utf8((void *) str, strlen(str), ps->data);	130	return ps->write_utf8((void *) str, strlen(str), ps->data);
131	}	131	}
132		132
133	/** Print one ASCII character.	133	/** Print one ASCII character.
134	*	134	*
135	* @param c ASCII character to be printed.	135	* @param c ASCII character to be printed.
136	* @param ps Output method.	136	* @param ps Output method.
137	*	137	*
138	* @return Number of characters printed.	138	* @return Number of characters printed.
139	*	139	*
140	*/	140	*/
141	static int printf_putchar(const char ch, printf_spec_t *ps)	141	static int printf_putchar(const char ch, printf_spec_t *ps)
142	{	142	{
143	if (!ascii_check(ch))	143	if (!ascii_check(ch))
144	return ps->write_utf8((void *) &invalch, 1, ps->data);	144	return ps->write_utf8((void *) &invalch, 1, ps->data);
145		145
146	return ps->write_utf8(&ch, 1, ps->data);	146	return ps->write_utf8(&ch, 1, ps->data);
147	}	147	}
148		148
149	/** Print one UTF-32 character.	149	/** Print one UTF-32 character.
150	*	150	*
151	* @param c UTF-32 character to be printed.	151	* @param c UTF-32 character to be printed.
152	* @param ps Output method.	152	* @param ps Output method.
153	*	153	*
154	* @return Number of characters printed.	154	* @return Number of characters printed.
155	*	155	*
156	*/	156	*/
157	static int printf_putwchar(const wchar_t ch, printf_spec_t *ps)	157	static int printf_putwchar(const wchar_t ch, printf_spec_t *ps)
158	{	158	{
159	if (!unicode_check(ch))	159	if (!unicode_check(ch))
160	return ps->write_utf8((void *) &invalch, 1, ps->data);	160	return ps->write_utf8((void *) &invalch, 1, ps->data);
161		161
162	return ps->write_utf32(&ch, 1, ps->data);	162	return ps->write_utf32(&ch, 1, ps->data);
163	}	163	}
164		164
165	/** Print one formatted ASCII character.	165	/** Print one formatted ASCII character.
166	*	166	*
167	* @param ch Character to print.	167	* @param ch Character to print.
168	* @param width Width modifier.	168	* @param width Width modifier.
169	* @param flags Flags that change the way the character is printed.	169	* @param flags Flags that change the way the character is printed.
170	*	170	*
171	* @return Number of characters printed, negative value on failure.	171	* @return Number of characters printed, negative value on failure.
172	*	172	*
173	*/	173	*/
174	static int print_char(const char ch, int width, uint32_t flags, printf_spec_t *ps)	174	static int print_char(const char ch, int width, uint32_t flags, printf_spec_t *ps)
175	{	175	{
176	count_t counter = 0;	176	count_t counter = 0;
177	if (!(flags & __PRINTF_FLAG_LEFTALIGNED)) {	177	if (!(flags & __PRINTF_FLAG_LEFTALIGNED)) {
178	while (--width > 0) {	178	while (--width > 0) {
179	/*	179	/*
180	* One space is consumed by the character itself, hence	180	* One space is consumed by the character itself, hence
181	* the predecrement.	181	* the predecrement.
182	*/	182	*/
183	if (printf_putchar(' ', ps) > 0)	183	if (printf_putchar(' ', ps) > 0)
184	counter++;	184	counter++;
185	}	185	}
186	}	186	}
187		187
188	if (printf_putchar(ch, ps) > 0)	188	if (printf_putchar(ch, ps) > 0)
189	counter++;	189	counter++;
190		190
191	while (--width > 0) {	191	while (--width > 0) {
192	/*	192	/*
193	* One space is consumed by the character itself, hence	193	* One space is consumed by the character itself, hence
194	* the predecrement.	194	* the predecrement.
195	*/	195	*/
196	if (printf_putchar(' ', ps) > 0)	196	if (printf_putchar(' ', ps) > 0)
197	counter++;	197	counter++;
198	}	198	}
199		199
200	return (int) (counter + 1);	200	return (int) (counter + 1);
201	}	201	}
202		202
203	/** Print one formatted UTF-32 character.	203	/** Print one formatted UTF-32 character.
204	*	204	*
205	* @param ch Character to print.	205	* @param ch Character to print.
206	* @param width Width modifier.	206	* @param width Width modifier.
207	* @param flags Flags that change the way the character is printed.	207	* @param flags Flags that change the way the character is printed.
208	*	208	*
209	* @return Number of characters printed, negative value on failure.	209	* @return Number of characters printed, negative value on failure.
210	*	210	*
211	*/	211	*/
212	static int print_wchar(const wchar_t ch, int width, uint32_t flags, printf_spec_t *ps)	212	static int print_wchar(const wchar_t ch, int width, uint32_t flags, printf_spec_t *ps)
213	{	213	{
214	count_t counter = 0;	214	count_t counter = 0;
215	if (!(flags & __PRINTF_FLAG_LEFTALIGNED)) {	215	if (!(flags & __PRINTF_FLAG_LEFTALIGNED)) {
216	while (--width > 0) {	216	while (--width > 0) {
217	/*	217	/*
218	* One space is consumed by the character itself, hence	218	* One space is consumed by the character itself, hence
219	* the predecrement.	219	* the predecrement.
220	*/	220	*/
221	if (printf_putchar(' ', ps) > 0)	221	if (printf_putchar(' ', ps) > 0)
222	counter++;	222	counter++;
223	}	223	}
224	}	224	}
225		225
226	if (printf_putwchar(ch, ps) > 0)	226	if (printf_putwchar(ch, ps) > 0)
227	counter++;	227	counter++;
228		228
229	while (--width > 0) {	229	while (--width > 0) {
230	/*	230	/*
231	* One space is consumed by the character itself, hence	231	* One space is consumed by the character itself, hence
232	* the predecrement.	232	* the predecrement.
233	*/	233	*/
234	if (printf_putchar(' ', ps) > 0)	234	if (printf_putchar(' ', ps) > 0)
235	counter++;	235	counter++;
236	}	236	}
237		237
238	return (int) (counter + 1);	238	return (int) (counter + 1);
239	}	239	}
240		240
241	/** Print UTF-8 string.	241	/** Print UTF-8 string.
242	*	242	*
243	* @param str UTF-8 string to be printed.	243	* @param str UTF-8 string to be printed.
244	* @param width Width modifier.	244	* @param width Width modifier.
245	* @param precision Precision modifier.	245	* @param precision Precision modifier.
246	* @param flags Flags that modify the way the string is printed.	246	* @param flags Flags that modify the way the string is printed.
247	*	247	*
248	* @return Number of UTF-8 characters printed, negative value on failure.	248	* @return Number of UTF-8 characters printed, negative value on failure.
249	*/	249	*/
250	static int print_utf8(char *str, int width, unsigned int precision,	250	static int print_utf8(char *str, int width, unsigned int precision,
251	uint32_t flags, printf_spec_t *ps)	251	uint32_t flags, printf_spec_t *ps)
252	{	252	{
253	if (str == NULL)	253	if (str == NULL)
254	return printf_putstr(nullstr, ps);	254	return printf_putstr(nullstr, ps);
255		255
256	/* Print leading spaces */	256	/* Print leading spaces */
257	size_t size = strlen_utf8(str);	257	size_t size = strlen_utf8(str);
258	if (precision == 0)	258	if (precision == 0)
259	precision = size;	259	precision = size;
260		260
261	count_t counter = 0;	261	count_t counter = 0;
262	width -= precision;	262	width -= precision;
263	if (!(flags & __PRINTF_FLAG_LEFTALIGNED)) {	263	if (!(flags & __PRINTF_FLAG_LEFTALIGNED)) {
264	while (width-- > 0) {	264	while (width-- > 0) {
265	if (printf_putchar(' ', ps) == 1)	265	if (printf_putchar(' ', ps) == 1)
266	counter++;	266	counter++;
267	}	267	}
268	}	268	}
269		269
270	int retval;	270	int retval;
271	size_t bytes = utf8_count_bytes(str, min(size, precision));	271	size_t bytes = utf8_count_bytes(str, min(size, precision));
272	if ((retval = printf_putnchars_utf8(str, bytes, ps)) < 0)	272	if ((retval = printf_putnchars_utf8(str, bytes, ps)) < 0)
273	return -counter;	273	return -counter;
274		274
275	counter += retval;	275	counter += retval;
276		276
277	while (width-- > 0) {	277	while (width-- > 0) {
278	if (printf_putchar(' ', ps) == 1)	278	if (printf_putchar(' ', ps) == 1)
279	counter++;	279	counter++;
280	}	280	}
281		281
282	return ((int) counter);	282	return ((int) counter);
283	}	283	}
284		284
285	/** Print UTF-32 string.	285	/** Print UTF-32 string.
286	*	286	*
287	* @param str UTF-32 string to be printed.	287	* @param str UTF-32 string to be printed.
288	* @param width Width modifier.	288	* @param width Width modifier.
289	* @param precision Precision modifier.	289	* @param precision Precision modifier.
290	* @param flags Flags that modify the way the string is printed.	290	* @param flags Flags that modify the way the string is printed.
291	*	291	*
292	* @return Number of UTF-32 characters printed, negative value on failure.	292	* @return Number of UTF-32 characters printed, negative value on failure.
293	*/	293	*/
294	static int print_utf32(wchar_t *str, int width, unsigned int precision,	294	static int print_utf32(wchar_t *str, int width, unsigned int precision,
295	uint32_t flags, printf_spec_t *ps)	295	uint32_t flags, printf_spec_t *ps)
296	{	296	{
297	if (str == NULL)	297	if (str == NULL)
298	return printf_putstr(nullstr, ps);	298	return printf_putstr(nullstr, ps);
299		299
300	/* Print leading spaces */	300	/* Print leading spaces */
301	size_t size = strlen_utf32(str);	301	size_t size = strlen_utf32(str);
302	if (precision == 0)	302	if (precision == 0)
303	precision = size;	303	precision = size;
304		304
305	count_t counter = 0;	305	count_t counter = 0;
306	width -= precision;	306	width -= precision;
307	if (!(flags & __PRINTF_FLAG_LEFTALIGNED)) {	307	if (!(flags & __PRINTF_FLAG_LEFTALIGNED)) {
308	while (width-- > 0) {	308	while (width-- > 0) {
309	if (printf_putchar(' ', ps) == 1)	309	if (printf_putchar(' ', ps) == 1)
310	counter++;	310	counter++;
311	}	311	}
312	}	312	}
313		313
314	int retval;	314	int retval;
315	size_t bytes = min(size, precision) * sizeof(wchar_t);	315	size_t bytes = min(size, precision) * sizeof(wchar_t);
316	if ((retval = printf_putnchars_utf32(str, bytes, ps)) < 0)	316	if ((retval = printf_putnchars_utf32(str, bytes, ps)) < 0)
317	return -counter;	317	return -counter;
318		318
319	counter += retval;	319	counter += retval;
320		320
321	while (width-- > 0) {	321	while (width-- > 0) {
322	if (printf_putchar(' ', ps) == 1)	322	if (printf_putchar(' ', ps) == 1)
323	counter++;	323	counter++;
324	}	324	}
325		325
326	return ((int) counter);	326	return ((int) counter);
327	}	327	}
328		328
329	/** Print a number in a given base.	329	/** Print a number in a given base.
330	*	330	*
331	* Print significant digits of a number in given base.	331	* Print significant digits of a number in given base.
332	*	332	*
333	* @param num Number to print.	333	* @param num Number to print.
334	* @param width Width modifier.	334	* @param width Width modifier.
335	* @param precision Precision modifier.	335	* @param precision Precision modifier.
336	* @param base Base to print the number in (must be between 2 and 16).	336	* @param base Base to print the number in (must be between 2 and 16).
337	* @param flags Flags that modify the way the number is printed.	337	* @param flags Flags that modify the way the number is printed.
338	*	338	*
339	* @return Number of characters printed.	339	* @return Number of characters printed.
340	*	340	*
341	*/	341	*/
342	static int print_number(uint64_t num, int width, int precision, int base,	342	static int print_number(uint64_t num, int width, int precision, int base,
343	uint32_t flags, printf_spec_t *ps)	343	uint32_t flags, printf_spec_t *ps)
344	{	344	{
345	char *digits;	345	char *digits;
346	if (flags & __PRINTF_FLAG_BIGCHARS)	346	if (flags & __PRINTF_FLAG_BIGCHARS)
347	digits = digits_big;	347	digits = digits_big;
348	else	348	else
349	digits = digits_small;	349	digits = digits_small;
350		350
351	char data[PRINT_NUMBER_BUFFER_SIZE];	351	char data[PRINT_NUMBER_BUFFER_SIZE];
352	char *ptr = &data[PRINT_NUMBER_BUFFER_SIZE - 1];	352	char *ptr = &data[PRINT_NUMBER_BUFFER_SIZE - 1];
353		353
354	/* Size of number with all prefixes and signs */	354	/* Size of number with all prefixes and signs */
355	int size = 0;	355	int size = 0;
356		356
357	/* Put zero at end of string */	357	/* Put zero at end of string */
358	*ptr-- = 0;	358	*ptr-- = 0;
359		359
360	if (num == 0) {	360	if (num == 0) {
361	*ptr-- = '0';	361	*ptr-- = '0';
362	size++;	362	size++;
363	} else {	363	} else {
364	do {	364	do {
365	*ptr-- = digits[num % base];	365	*ptr-- = digits[num % base];
366	size++;	366	size++;
367	} while (num /= base);	367	} while (num /= base);
368	}	368	}
369		369
370	/* Size of plain number */	370	/* Size of plain number */
371	int number_size = size;	371	int number_size = size;
372		372
373	/*	373	/*
374	* Collect the sum of all prefixes/signs/etc. to calculate padding and	374	* Collect the sum of all prefixes/signs/etc. to calculate padding and
375	* leading zeroes.	375	* leading zeroes.
376	*/	376	*/
377	if (flags & __PRINTF_FLAG_PREFIX) {	377	if (flags & __PRINTF_FLAG_PREFIX) {
378	switch(base) {	378	switch(base) {
379	case 2:	379	case 2:
380	/* Binary formating is not standard, but usefull */	380	/* Binary formating is not standard, but usefull */
381	size += 2;	381	size += 2;
382	break;	382	break;
383	case 8:	383	case 8:
384	size++;	384	size++;
385	break;	385	break;
386	case 16:	386	case 16:
387	size += 2;	387	size += 2;
388	break;	388	break;
389	}	389	}
390	}	390	}
391		391
392	char sgn = 0;	392	char sgn = 0;
393	if (flags & __PRINTF_FLAG_SIGNED) {	393	if (flags & __PRINTF_FLAG_SIGNED) {
394	if (flags & __PRINTF_FLAG_NEGATIVE) {	394	if (flags & __PRINTF_FLAG_NEGATIVE) {
395	sgn = '-';	395	sgn = '-';
396	size++;	396	size++;
397	} else if (flags & __PRINTF_FLAG_SHOWPLUS) {	397	} else if (flags & __PRINTF_FLAG_SHOWPLUS) {
398	sgn = '+';	398	sgn = '+';
399	size++;	399	size++;
400	} else if (flags & __PRINTF_FLAG_SPACESIGN) {	400	} else if (flags & __PRINTF_FLAG_SPACESIGN) {
401	sgn = ' ';	401	sgn = ' ';
402	size++;	402	size++;
403	}	403	}
404	}	404	}
405		405
406	if (flags & __PRINTF_FLAG_LEFTALIGNED)	406	if (flags & __PRINTF_FLAG_LEFTALIGNED)
407	flags &= ~__PRINTF_FLAG_ZEROPADDED;	407	flags &= ~__PRINTF_FLAG_ZEROPADDED;
408		408
409	/*	409	/*
410	* If the number is left-aligned or precision is specified then	410	* If the number is left-aligned or precision is specified then
411	* padding with zeros is ignored.	411	* padding with zeros is ignored.
412	*/	412	*/
413	if (flags & __PRINTF_FLAG_ZEROPADDED) {	413	if (flags & __PRINTF_FLAG_ZEROPADDED) {
414	if ((precision == 0) && (width > size))	414	if ((precision == 0) && (width > size))
415	precision = width - size + number_size;	415	precision = width - size + number_size;
416	}	416	}
417		417
418	/* Print leading spaces */	418	/* Print leading spaces */
419	if (number_size > precision) {	419	if (number_size > precision) {
420	/* Print the whole number, not only a part */	420	/* Print the whole number, not only a part */
421	precision = number_size;	421	precision = number_size;
422	}	422	}
423		423
424	width -= precision + size - number_size;	424	width -= precision + size - number_size;
425	count_t counter = 0;	425	count_t counter = 0;
426		426
427	if (!(flags & __PRINTF_FLAG_LEFTALIGNED)) {	427	if (!(flags & __PRINTF_FLAG_LEFTALIGNED)) {
428	while (width-- > 0) {	428	while (width-- > 0) {
429	if (printf_putchar(' ', ps) == 1)	429	if (printf_putchar(' ', ps) == 1)
430	counter++;	430	counter++;
431	}	431	}
432	}	432	}
433		433
434	/* Print sign */	434	/* Print sign */
435	if (sgn) {	435	if (sgn) {
436	if (printf_putchar(sgn, ps) == 1)	436	if (printf_putchar(sgn, ps) == 1)
437	counter++;	437	counter++;
438	}	438	}
439		439
440	/* Print prefix */	440	/* Print prefix */
441	if (flags & __PRINTF_FLAG_PREFIX) {	441	if (flags & __PRINTF_FLAG_PREFIX) {
442	switch(base) {	442	switch(base) {
443	case 2:	443	case 2:
444	/* Binary formating is not standard, but usefull */	444	/* Binary formating is not standard, but usefull */
445	if (printf_putchar('0', ps) == 1)	445	if (printf_putchar('0', ps) == 1)
446	counter++;	446	counter++;
447	if (flags & __PRINTF_FLAG_BIGCHARS) {	447	if (flags & __PRINTF_FLAG_BIGCHARS) {
448	if (printf_putchar('B', ps) == 1)	448	if (printf_putchar('B', ps) == 1)
449	counter++;	449	counter++;
450	} else {	450	} else {
451	if (printf_putchar('b', ps) == 1)	451	if (printf_putchar('b', ps) == 1)
452	counter++;	452	counter++;
453	}	453	}
454	break;	454	break;
455	case 8:	455	case 8:
456	if (printf_putchar('o', ps) == 1)	456	if (printf_putchar('o', ps) == 1)
457	counter++;	457	counter++;
458	break;	458	break;
459	case 16:	459	case 16:
460	if (printf_putchar('0', ps) == 1)	460	if (printf_putchar('0', ps) == 1)
461	counter++;	461	counter++;
462	if (flags & __PRINTF_FLAG_BIGCHARS) {	462	if (flags & __PRINTF_FLAG_BIGCHARS) {
463	if (printf_putchar('X', ps) == 1)	463	if (printf_putchar('X', ps) == 1)
464	counter++;	464	counter++;
465	} else {	465	} else {
466	if (printf_putchar('x', ps) == 1)	466	if (printf_putchar('x', ps) == 1)
467	counter++;	467	counter++;
468	}	468	}
469	break;	469	break;
470	}	470	}
471	}	471	}
472		472
473	/* Print leading zeroes */	473	/* Print leading zeroes */
474	precision -= number_size;	474	precision -= number_size;
475	while (precision-- > 0) {	475	while (precision-- > 0) {
476	if (printf_putchar('0', ps) == 1)	476	if (printf_putchar('0', ps) == 1)
477	counter++;	477	counter++;
478	}	478	}
479		479
480	/* Print the number itself */	480	/* Print the number itself */
481	int retval;	481	int retval;
482	if ((retval = printf_putstr(++ptr, ps)) > 0)	482	if ((retval = printf_putstr(++ptr, ps)) > 0)
483	counter += retval;	483	counter += retval;
484		484
485	/* Print tailing spaces */	485	/* Print tailing spaces */
486		486
487	while (width-- > 0) {	487	while (width-- > 0) {
488	if (printf_putchar(' ', ps) == 1)	488	if (printf_putchar(' ', ps) == 1)
489	counter++;	489	counter++;
490	}	490	}
491		491
492	return ((int) counter);	492	return ((int) counter);
493	}	493	}
494		494
495	/** Print formatted string.	495	/** Print formatted string.
496	*	496	*
497	* Print string formatted according to the fmt parameter and variadic arguments.	497	* Print string formatted according to the fmt parameter and variadic arguments.
498	* Each formatting directive must have the following form:	498	* Each formatting directive must have the following form:
499	*	499	*
500	* \% [ FLAGS ] [ WIDTH ] [ .PRECISION ] [ TYPE ] CONVERSION	500	* \% [ FLAGS ] [ WIDTH ] [ .PRECISION ] [ TYPE ] CONVERSION

Subversion Repositories HelenOS

(root)/trunk/kernel/generic/src/printf/printf_core.c @ 4598 – Rev 4180 → 4183