WebSVN – HelenOS – Diff – /trunk/uspace/libc/generic/io/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.
 */
 
/** @addtogroup libc
 * @{
 */
/**
 * @file
 * @brief   Printing functions.
 */
 
#include <unistd.h>
#include <stdio.h>
#include <io/printf_core.h>
#include <ctype.h>
#include <string.h>
/* For serialization */
#include <async.h>
 
#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,
    PrintfQualifierSizeT,
    PrintfQualifierPointer
} qualifier_t;
 
static char digits_small[] = "0123456789abcdef";    /**< Small hexadecimal characters */
static char digits_big[] = "0123456789ABCDEF";      /**< Big hexadecimal characters */
 
/** 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 number of printed characters
 */
static int printf_putnchars(const char * buf, size_t count, struct printf_spec *ps)
{
    return ps->write((void *)buf, count, ps->data);
}
 
/** Print string without added newline
 * @param str string to print
 * @param ps write function specification and support data
 * @return number of printed characters
 */
static int printf_putstr(const char * str, struct printf_spec *ps)
{
    size_t count;
   
    if (str == NULL) {
        return printf_putnchars("(NULL)", 6, ps);
    }
 
    for (count = 0; str[count] != 0; count++);
 
    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 number of printed characters
 */
static int printf_putchar(int c, struct printf_spec *ps)
{
    unsigned char ch = c;
   
    return ps->write((void *) &ch, 1, ps->data);
}
 
/** Print one formatted character
 * @param c character to print
 * @param width
 * @param flags
 * @return number of printed characters
 */
static int print_char(char c, int width, uint64_t 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 */
            if (printf_putchar(' ', ps) > 0)   
                ++counter;
        }
    }
   
    if (printf_putchar(c, ps) > 0)
        counter++;
   
    while (--width > 0) { /* one space is consumed by character itself hence predecrement */
        if (printf_putchar(' ', ps) > 0)
            ++counter;
    }
   
    return ++counter;
}
 
/** Print one string
 * @param s string
 * @param width
 * @param precision
 * @param flags
 * @return number of printed characters
 */
                       
static int print_string(char *s, int width, int precision, uint64_t flags, struct printf_spec *ps)
{
    int counter = 0;
    size_t size;
    int retval;
 
    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) {  
            if (printf_putchar(' ', ps) == 1)  
                counter++;
        }
    }
 
    while (precision > size) {
        precision--;
        if (printf_putchar(' ', ps) == 1)  
            ++counter;
    }
   
    if ((retval = printf_putnchars(s, precision, ps)) < 0) {
        return -counter;
    }
 
    counter += retval; 
 
    while (width-- > 0) {
        if (printf_putchar(' ', ps) == 1)  
            ++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 printed characters
 *
 */
static int print_number(uint64_t num, int width, int precision, int base , uint64_t 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 */
    char sgn;
    int retval;
    int counter = 0;
   
    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) {  
            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 number itself */
 
    if ((retval = printf_putstr(++ptr, ps)) > 0) {
        counter += retval;
    }
   
    /* print ending spaces */
   
    while (width-- > 0) {  
        if (printf_putchar(' ', ps) == 1)  
            counter++;
    }
 
    return 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 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"   Type size_t.@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' or '\%#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 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 */
    uint64_t number; /* argument value */
    size_t  size; /* byte size of integer parameter */
    int width, precision;
    uint64_t flags;
   
    /* Don't let other threads interfere */
    async_serialize_start();
 
    counter = 0;
   
    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)) < 0) { /* error */
                    goto minus_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':   /* size_t */
                qualifier = PrintfQualifierSizeT;
                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)) < 0) {
                    goto minus_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)) < 0) {
                    goto minus_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 = (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;
            case PrintfQualifierSizeT:
                size = sizeof(size_t);
                number = (uint64_t)va_arg(ap, size_t);
                break;
            default: /* Unknown qualifier */
                goto minus_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 ) {
                goto minus_out;
            };
 
            counter += retval;
            j = i + 1;
        }  
next_char:
           
        ++i;
    }
   
    if (i > j) {
        if ((retval = printf_putnchars(&fmt[j], (size_t)(i - j), ps)) < 0) { /* error */
            goto minus_out;
        }
        counter += retval;
    }
   
    async_serialize_end();
    return counter;
minus_out:
    async_serialize_end();
    return -counter;
}
 
/** @}
 */
 

Rev 2070	Rev 2071
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	/** @addtogroup libc	30	/** @addtogroup libc
31	* @{	31	* @{
32	*/	32	*/
33	/**	33	/**
34	* @file	34	* @file
35	* @brief Printing functions.	35	* @brief Printing functions.
36	*/	36	*/
37		37
38	#include <unistd.h>	38	#include <unistd.h>
39	#include <stdio.h>	39	#include <stdio.h>
40	#include <io/printf_core.h>	40	#include <io/printf_core.h>
41	#include <ctype.h>	41	#include <ctype.h>
42	#include <string.h>	42	#include <string.h>
43	/* For serialization */	43	/* For serialization */
44	#include <async.h>	44	#include <async.h>
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	PrintfQualifierSizeT,	68	PrintfQualifierSizeT,
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	/** Print count chars from buffer without adding newline	75	/** Print count chars from buffer without adding newline
76	* @param buf Buffer with size at least count bytes - NULL pointer NOT allowed!	76	* @param buf Buffer with size at least count bytes - NULL pointer NOT allowed!
77	* @param count	77	* @param count
78	* @param ps output method and its data	78	* @param ps output method and its data
79	* @return number of printed characters	79	* @return number of printed characters
80	*/	80	*/
81	static int printf_putnchars(const char * buf, size_t count, struct printf_spec *ps)	81	static int printf_putnchars(const char * buf, size_t count, struct printf_spec *ps)
82	{	82	{
83	return ps->write((void *)buf, count, ps->data);	83	return ps->write((void *)buf, count, ps->data);
84	}	84	}
85		85
86	/** Print string without added newline	86	/** Print string without added newline
87	* @param str string to print	87	* @param str string to print
88	* @param ps write function specification and support data	88	* @param ps write function specification and support data
89	* @return number of printed characters	89	* @return number of printed characters
90	*/	90	*/
91	static int printf_putstr(const char * str, struct printf_spec *ps)	91	static int printf_putstr(const char * str, struct printf_spec *ps)
92	{	92	{
93	size_t count;	93	size_t count;
94		94
95	if (str == NULL) {	95	if (str == NULL) {
96	return printf_putnchars("(NULL)", 6, ps);	96	return printf_putnchars("(NULL)", 6, ps);
97	}	97	}
98		98
99	for (count = 0; str[count] != 0; count++);	99	for (count = 0; str[count] != 0; count++);
100		100
101	if (ps->write((void *) str, count, ps->data) == count) {	101	if (ps->write((void *) str, count, ps->data) == count) {
102	return 0;	102	return 0;
103	}	103	}
104		104
105	return EOF;	105	return EOF;
106	}	106	}
107		107
108	/** Print one character to output	108	/** Print one character to output
109	* @param c one character	109	* @param c one character
110	* @param ps output method	110	* @param ps output method
111	* @return number of printed characters	111	* @return number of printed characters
112	*/	112	*/
113	static int printf_putchar(int c, struct printf_spec *ps)	113	static int printf_putchar(int c, struct printf_spec *ps)
114	{	114	{
115	unsigned char ch = c;	115	unsigned char ch = c;
116		116
117	return ps->write((void *) &ch, 1, ps->data);	117	return ps->write((void *) &ch, 1, ps->data);
118	}	118	}
119		119
120	/** Print one formatted character	120	/** Print one formatted character
121	* @param c character to print	121	* @param c character to print
122	* @param width	122	* @param width
123	* @param flags	123	* @param flags
124	* @return number of printed characters	124	* @return number of printed characters
125	*/	125	*/
126	static int print_char(char c, int width, uint64_t flags, struct printf_spec *ps)	126	static int print_char(char c, int width, uint64_t flags, struct printf_spec *ps)
127	{	127	{
128	int counter = 0;	128	int counter = 0;
129		129
130	if (!(flags & __PRINTF_FLAG_LEFTALIGNED)) {	130	if (!(flags & __PRINTF_FLAG_LEFTALIGNED)) {
131	while (--width > 0) { /* one space is consumed by character itself hence predecrement */	131	while (--width > 0) { /* one space is consumed by character itself hence predecrement */
132	if (printf_putchar(' ', ps) > 0)	132	if (printf_putchar(' ', ps) > 0)
133	++counter;	133	++counter;
134	}	134	}
135	}	135	}
136		136
137	if (printf_putchar(c, ps) > 0)	137	if (printf_putchar(c, ps) > 0)
138	counter++;	138	counter++;
139		139
140	while (--width > 0) { /* one space is consumed by character itself hence predecrement */	140	while (--width > 0) { /* one space is consumed by character itself hence predecrement */
141	if (printf_putchar(' ', ps) > 0)	141	if (printf_putchar(' ', ps) > 0)
142	++counter;	142	++counter;
143	}	143	}
144		144
145	return ++counter;	145	return ++counter;
146	}	146	}
147		147
148	/** Print one string	148	/** Print one string
149	* @param s string	149	* @param s string
150	* @param width	150	* @param width
151	* @param precision	151	* @param precision
152	* @param flags	152	* @param flags
153	* @return number of printed characters	153	* @return number of printed characters
154	*/	154	*/
155		155
156	static int print_string(char s, int width, int precision, uint64_t flags, struct printf_spec ps)	156	static int print_string(char s, int width, int precision, uint64_t flags, struct printf_spec ps)
157	{	157	{
158	int counter = 0;	158	int counter = 0;
159	size_t size;	159	size_t size;
160	int retval;	160	int retval;
161		161
162	if (s == NULL) {	162	if (s == NULL) {
163	return printf_putstr("(NULL)", ps);	163	return printf_putstr("(NULL)", ps);
164	}	164	}
165		165
166	size = strlen(s);	166	size = strlen(s);
167		167
168	/* print leading spaces */	168	/* print leading spaces */
169		169
170	if (precision == 0)	170	if (precision == 0)
171	precision = size;	171	precision = size;
172		172
173	width -= precision;	173	width -= precision;
174		174
175	if (!(flags & __PRINTF_FLAG_LEFTALIGNED)) {	175	if (!(flags & __PRINTF_FLAG_LEFTALIGNED)) {
176	while (width-- > 0) {	176	while (width-- > 0) {
177	if (printf_putchar(' ', ps) == 1)	177	if (printf_putchar(' ', ps) == 1)
178	counter++;	178	counter++;
179	}	179	}
180	}	180	}
181		181
182	while (precision > size) {	182	while (precision > size) {
183	precision--;	183	precision--;
184	if (printf_putchar(' ', ps) == 1)	184	if (printf_putchar(' ', ps) == 1)
185	++counter;	185	++counter;
186	}	186	}
187		187
188	if ((retval = printf_putnchars(s, precision, ps)) < 0) {	188	if ((retval = printf_putnchars(s, precision, ps)) < 0) {
189	return -counter;	189	return -counter;
190	}	190	}
191		191
192	counter += retval;	192	counter += retval;
193		193
194	while (width-- > 0) {	194	while (width-- > 0) {
195	if (printf_putchar(' ', ps) == 1)	195	if (printf_putchar(' ', ps) == 1)
196	++counter;	196	++counter;
197	}	197	}
198		198
199	return counter;	199	return counter;
200	}	200	}
201		201
202		202
203	/** Print number in given base	203	/** Print number in given base
204	*	204	*
205	* Print significant digits of a number in given	205	* Print significant digits of a number in given
206	* base.	206	* base.
207	*	207	*
208	* @param num Number to print.	208	* @param num Number to print.
209	* @param width	209	* @param width
210	* @param precision	210	* @param precision
211	* @param base Base to print the number in (should	211	* @param base Base to print the number in (should
212	* be in range 2 .. 16).	212	* be in range 2 .. 16).
213	* @param flags output modifiers	213	* @param flags output modifiers
214	* @return number of printed characters	214	* @return number of printed characters
215	*	215	*
216	*/	216	*/
217	static int print_number(uint64_t num, int width, int precision, int base , uint64_t flags, struct printf_spec *ps)	217	static int print_number(uint64_t num, int width, int precision, int base , uint64_t flags, struct printf_spec *ps)
218	{	218	{
219	char *digits = digits_small;	219	char *digits = digits_small;
220	char d[PRINT_NUMBER_BUFFER_SIZE]; /* this is good enough even for base == 2, prefix and sign */	220	char d[PRINT_NUMBER_BUFFER_SIZE]; /* this is good enough even for base == 2, prefix and sign */
221	char *ptr = &d[PRINT_NUMBER_BUFFER_SIZE - 1];	221	char *ptr = &d[PRINT_NUMBER_BUFFER_SIZE - 1];
222	int size = 0; /* size of number with all prefixes and signs */	222	int size = 0; /* size of number with all prefixes and signs */
223	int number_size; /* size of plain number */	223	int number_size; /* size of plain number */
224	char sgn;	224	char sgn;
225	int retval;	225	int retval;
226	int counter = 0;	226	int counter = 0;
227		227
228	if (flags & __PRINTF_FLAG_BIGCHARS)	228	if (flags & __PRINTF_FLAG_BIGCHARS)
229	digits = digits_big;	229	digits = digits_big;
230		230
231	ptr-- = 0; / Put zero at end of string */	231	ptr-- = 0; / Put zero at end of string */
232		232
233	if (num == 0) {	233	if (num == 0) {
234	*ptr-- = '0';	234	*ptr-- = '0';
235	size++;	235	size++;
236	} else {	236	} else {
237	do {	237	do {
238	*ptr-- = digits[num % base];	238	*ptr-- = digits[num % base];
239	size++;	239	size++;
240	} while (num /= base);	240	} while (num /= base);
241	}	241	}
242		242
243	number_size = size;	243	number_size = size;
244		244
245	/* Collect sum of all prefixes/signs/... to calculate padding and leading zeroes */	245	/* Collect sum of all prefixes/signs/... to calculate padding and leading zeroes */
246	if (flags & __PRINTF_FLAG_PREFIX) {	246	if (flags & __PRINTF_FLAG_PREFIX) {
247	switch(base) {	247	switch(base) {
248	case 2: /* Binary formating is not standard, but usefull */	248	case 2: /* Binary formating is not standard, but usefull */
249	size += 2;	249	size += 2;
250	break;	250	break;
251	case 8:	251	case 8:
252	size++;	252	size++;
253	break;	253	break;
254	case 16:	254	case 16:
255	size += 2;	255	size += 2;
256	break;	256	break;
257	}	257	}
258	}	258	}
259		259
260	sgn = 0;	260	sgn = 0;
261	if (flags & __PRINTF_FLAG_SIGNED) {	261	if (flags & __PRINTF_FLAG_SIGNED) {
262	if (flags & __PRINTF_FLAG_NEGATIVE) {	262	if (flags & __PRINTF_FLAG_NEGATIVE) {
263	sgn = '-';	263	sgn = '-';
264	size++;	264	size++;
265	} else if (flags & __PRINTF_FLAG_SHOWPLUS) {	265	} else if (flags & __PRINTF_FLAG_SHOWPLUS) {
266	sgn = '+';	266	sgn = '+';
267	size++;	267	size++;
268	} else if (flags & __PRINTF_FLAG_SPACESIGN) {	268	} else if (flags & __PRINTF_FLAG_SPACESIGN) {
269	sgn = ' ';	269	sgn = ' ';
270	size++;	270	size++;
271	}	271	}
272	}	272	}
273		273
274	if (flags & __PRINTF_FLAG_LEFTALIGNED) {	274	if (flags & __PRINTF_FLAG_LEFTALIGNED) {
275	flags &= ~__PRINTF_FLAG_ZEROPADDED;	275	flags &= ~__PRINTF_FLAG_ZEROPADDED;
276	}	276	}
277		277
278	/* if number is leftaligned or precision is specified then zeropadding is ignored */	278	/* if number is leftaligned or precision is specified then zeropadding is ignored */
279	if (flags & __PRINTF_FLAG_ZEROPADDED) {	279	if (flags & __PRINTF_FLAG_ZEROPADDED) {
280	if ((precision == 0) && (width > size)) {	280	if ((precision == 0) && (width > size)) {
281	precision = width - size + number_size;	281	precision = width - size + number_size;
282	}	282	}
283	}	283	}
284		284
285	/* print leading spaces */	285	/* print leading spaces */
286	if (number_size > precision) /* We must print whole number not only a part */	286	if (number_size > precision) /* We must print whole number not only a part */
287	precision = number_size;	287	precision = number_size;
288		288
289	width -= precision + size - number_size;	289	width -= precision + size - number_size;
290		290
291	if (!(flags & __PRINTF_FLAG_LEFTALIGNED)) {	291	if (!(flags & __PRINTF_FLAG_LEFTALIGNED)) {
292	while (width-- > 0) {	292	while (width-- > 0) {
293	if (printf_putchar(' ', ps) == 1)	293	if (printf_putchar(' ', ps) == 1)
294	counter++;	294	counter++;
295	}	295	}
296	}	296	}
297		297
298	/* print sign */	298	/* print sign */
299	if (sgn) {	299	if (sgn) {
300	if (printf_putchar(sgn, ps) == 1)	300	if (printf_putchar(sgn, ps) == 1)
301	counter++;	301	counter++;
302	}	302	}
303		303
304	/* print prefix */	304	/* print prefix */
305		305
306	if (flags & __PRINTF_FLAG_PREFIX) {	306	if (flags & __PRINTF_FLAG_PREFIX) {
307	switch(base) {	307	switch(base) {
308	case 2: /* Binary formating is not standard, but usefull */	308	case 2: /* Binary formating is not standard, but usefull */
309	if (printf_putchar('0', ps) == 1)	309	if (printf_putchar('0', ps) == 1)
310	counter++;	310	counter++;
311	if (flags & __PRINTF_FLAG_BIGCHARS) {	311	if (flags & __PRINTF_FLAG_BIGCHARS) {
312	if (printf_putchar('B', ps) == 1)	312	if (printf_putchar('B', ps) == 1)
313	counter++;	313	counter++;
314	} else {	314	} else {
315	if (printf_putchar('b', ps) == 1)	315	if (printf_putchar('b', ps) == 1)
316	counter++;	316	counter++;
317	}	317	}
318	break;	318	break;
319	case 8:	319	case 8:
320	if (printf_putchar('o', ps) == 1)	320	if (printf_putchar('o', ps) == 1)
321	counter++;	321	counter++;
322	break;	322	break;
323	case 16:	323	case 16:
324	if (printf_putchar('0', ps) == 1)	324	if (printf_putchar('0', ps) == 1)
325	counter++;	325	counter++;
326	if (flags & __PRINTF_FLAG_BIGCHARS) {	326	if (flags & __PRINTF_FLAG_BIGCHARS) {
327	if (printf_putchar('X', ps) == 1)	327	if (printf_putchar('X', ps) == 1)
328	counter++;	328	counter++;
329	} else {	329	} else {
330	if (printf_putchar('x', ps) == 1)	330	if (printf_putchar('x', ps) == 1)
331	counter++;	331	counter++;
332	}	332	}
333	break;	333	break;
334	}	334	}
335	}	335	}
336		336
337	/* print leading zeroes */	337	/* print leading zeroes */
338	precision -= number_size;	338	precision -= number_size;
339	while (precision-- > 0) {	339	while (precision-- > 0) {
340	if (printf_putchar('0', ps) == 1)	340	if (printf_putchar('0', ps) == 1)
341	counter++;	341	counter++;
342	}	342	}
343		343
344		344
345	/* print number itself */	345	/* print number itself */
346		346
347	if ((retval = printf_putstr(++ptr, ps)) > 0) {	347	if ((retval = printf_putstr(++ptr, ps)) > 0) {
348	counter += retval;	348	counter += retval;
349	}	349	}
350		350
351	/* print ending spaces */	351	/* print ending spaces */
352		352
353	while (width-- > 0) {	353	while (width-- > 0) {
354	if (printf_putchar(' ', ps) == 1)	354	if (printf_putchar(' ', ps) == 1)
355	counter++;	355	counter++;
356	}	356	}
357		357
358	return counter;	358	return counter;
359	}	359	}
360		360
361		361
362	/** Print formatted string.	362	/** Print formatted string.
363	*	363	*
364	* Print string formatted according to the fmt parameter	364	* Print string formatted according to the fmt parameter
365	* and variadic arguments. Each formatting directive	365	* and variadic arguments. Each formatting directive
366	* must have the following form:	366	* must have the following form:
367	*	367	*
368	* \% [ FLAGS ] [ WIDTH ] [ .PRECISION ] [ TYPE ] CONVERSION	368	* \% [ FLAGS ] [ WIDTH ] [ .PRECISION ] [ TYPE ] CONVERSION
369	*	369	*
370	* FLAGS:@n	370	* FLAGS:@n
371	* - "#" Force to print prefix.	371	* - "#" Force to print prefix.
372	* For conversion \%o the prefix is 0, for %x and \%X prefixes are 0x and 0X	372	* For conversion \%o the prefix is 0, for %x and \%X prefixes are 0x and 0X
373	* and for conversion \%b the prefix is 0b.	373	* and for conversion \%b the prefix is 0b.
374	*	374	*
375	* - "-" Align to left.	375	* - "-" Align to left.
376	*	376	*
377	* - "+" Print positive sign just as negative.	377	* - "+" Print positive sign just as negative.
378	*	378	*
379	* - " " If the printed number is positive and "+" flag is not set, print space in	379	* - " " If the printed number is positive and "+" flag is not set, print space in
380	* place of sign.	380	* place of sign.
381	*	381	*
382	* - "0" Print 0 as padding instead of spaces. Zeroes are placed between sign and the	382	* - "0" Print 0 as padding instead of spaces. Zeroes are placed between sign and the
383	* rest of the number. This flag is ignored if "-" flag is specified.	383	* rest of the number. This flag is ignored if "-" flag is specified.
384	*	384	*
385	* WIDTH:@n	385	* WIDTH:@n
386	* - Specify minimal width of printed argument. If it is bigger, width is ignored.	386	* - Specify minimal width of printed argument. If it is bigger, width is ignored.
387	* If width is specified with a "*" character instead of number, width is taken from	387	* If width is specified with a "*" character instead of number, width is taken from
388	* parameter list. And integer parameter is expected before parameter for processed	388	* parameter list. And integer parameter is expected before parameter for processed
389	* conversion specification. If this value is negative its absolute value is taken	389	* conversion specification. If this value is negative its absolute value is taken
390	* and the "-" flag is set.	390	* and the "-" flag is set.
391	*	391	*
392	* PRECISION:@n	392	* PRECISION:@n
393	* - Value precision. For numbers it specifies minimum valid numbers.	393	* - Value precision. For numbers it specifies minimum valid numbers.
394	* Smaller numbers are printed with leading zeroes. Bigger numbers are not affected.	394	* Smaller numbers are printed with leading zeroes. Bigger numbers are not affected.
395	* Strings with more than precision characters are cut off.	395	* Strings with more than precision characters are cut off.
396	* Just as with width, an "*" can be used used instead of a number.	396	* Just as with width, an "*" can be used used instead of a number.
397	* An integer value is then expected in parameters. When both width and precision	397	* An integer value is then expected in parameters. When both width and precision
398	* are specified using "*", the first parameter is used for width and the second one	398	* are specified using "*", the first parameter is used for width and the second one
399	* for precision.	399	* for precision.
400	*	400	*
401	* TYPE:@n	401	* TYPE:@n
402	* - "hh" Signed or unsigned char.@n	402	* - "hh" Signed or unsigned char.@n
403	* - "h" Signed or usigned short.@n	403	* - "h" Signed or usigned short.@n
404	* - "" Signed or usigned int (default value).@n	404	* - "" Signed or usigned int (default value).@n
405	* - "l" Signed or usigned long int.@n	405	* - "l" Signed or usigned long int.@n
406	* - "ll" Signed or usigned long long int.@n	406	* - "ll" Signed or usigned long long int.@n
407	* - "z" Type size_t.@n	407	* - "z" Type size_t.@n
408	*	408	*
409	*	409	*
410	* CONVERSION:@n	410	* CONVERSION:@n
411	* - % Print percentile character itself.	411	* - % Print percentile character itself.
412	*	412	*
413	* - c Print single character.	413	* - c Print single character.
414	*	414	*
415	* - s Print zero terminated string. If a NULL value is passed as value, "(NULL)" is printed instead.	415	* - s Print zero terminated string. If a NULL value is passed as value, "(NULL)" is printed instead.
416	*	416	*
417	* - P, p Print value of a pointer. Void * value is expected and it is printed in hexadecimal notation with prefix	417	* - P, p Print value of a pointer. Void * value is expected and it is printed in hexadecimal notation with prefix
418	* (as with '\%#X' or '\%#x' for 32bit or '\%#X' or '\%#x' for 64bit long pointers).	418	* (as with '\%#X' or '\%#x' for 32bit or '\%#X' or '\%#x' for 64bit long pointers).
419	*	419	*
420	* - b Print value as unsigned binary number. Prefix is not printed by default. (Nonstandard extension.)	420	* - b Print value as unsigned binary number. Prefix is not printed by default. (Nonstandard extension.)
421	*	421	*
422	* - o Print value as unsigned octal number. Prefix is not printed by default.	422	* - o Print value as unsigned octal number. Prefix is not printed by default.
423	*	423	*
424	* - d,i Print signed decimal number. There is no difference between d and i conversion.	424	* - d,i Print signed decimal number. There is no difference between d and i conversion.
425	*	425	*
426	* - u Print unsigned decimal number.	426	* - u Print unsigned decimal number.
427	*	427	*
428	* - X, x Print hexadecimal number with upper- or lower-case. Prefix is not printed by default.	428	* - X, x Print hexadecimal number with upper- or lower-case. Prefix is not printed by default.
429	*	429	*
430	* All other characters from fmt except the formatting directives	430	* All other characters from fmt except the formatting directives
431	* are printed in verbatim.	431	* are printed in verbatim.
432	*	432	*
433	* @param fmt Formatting NULL terminated string.	433	* @param fmt Formatting NULL terminated string.
434	* @return Number of printed characters or negative value on failure.	434	* @return Number of printed characters or negative value on failure.
435	*/	435	*/
436	int printf_core(const char fmt, struct printf_spec ps, va_list ap)	436	int printf_core(const char fmt, struct printf_spec ps, va_list ap)
437	{	437	{
438	int i = 0, j = 0; /* i is index of currently processed char from fmt, j is index to the first not printed nonformating character */	438	int i = 0, j = 0; /* i is index of currently processed char from fmt, j is index to the first not printed nonformating character */
439	int end;	439	int end;
440	int counter; /* counter of printed characters */	440	int counter; /* counter of printed characters */
441	int retval; /* used to store return values from called functions */	441	int retval; /* used to store return values from called functions */
442	char c;	442	char c;
443	qualifier_t qualifier; /* type of argument */	443	qualifier_t qualifier; /* type of argument */
444	int base; /* base in which will be parameter (numbers only) printed */	444	int base; /* base in which will be parameter (numbers only) printed */
445	uint64_t number; /* argument value */	445	uint64_t number; /* argument value */
446	size_t size; /* byte size of integer parameter */	446	size_t size; /* byte size of integer parameter */
447	int width, precision;	447	int width, precision;
448	uint64_t flags;	448	uint64_t flags;
449		449
450	/* Don't let other threads interfere */	450	/* Don't let other threads interfere */
451	async_serialize_start();	451	async_serialize_start();
452		452
453	counter = 0;	453	counter = 0;
454		454
455	while ((c = fmt[i])) {	455	while ((c = fmt[i])) {
456	/* control character */	456	/* control character */
457	if (c == '%' ) {	457	if (c == '%' ) {
458	/* print common characters if any processed */	458	/* print common characters if any processed */
459	if (i > j) {	459	if (i > j) {
460	if ((retval = printf_putnchars(&fmt[j], (size_t)(i - j), ps)) < 0) { /* error */	460	if ((retval = printf_putnchars(&fmt[j], (size_t)(i - j), ps)) < 0) { /* error */
461	goto minus_out;	461	goto minus_out;
462	}	462	}
463	counter += retval;	463	counter += retval;
464	}	464	}
465		465
466	j = i;	466	j = i;
467	/* parse modifiers */	467	/* parse modifiers */
468	flags = 0;	468	flags = 0;
469	end = 0;	469	end = 0;
470		470
471	do {	471	do {
472	++i;	472	++i;
473	switch (c = fmt[i]) {	473	switch (c = fmt[i]) {
474	case '#': flags \|= __PRINTF_FLAG_PREFIX; break;	474	case '#': flags \|= __PRINTF_FLAG_PREFIX; break;
475	case '-': flags \|= __PRINTF_FLAG_LEFTALIGNED; break;	475	case '-': flags \|= __PRINTF_FLAG_LEFTALIGNED; break;
476	case '+': flags \|= __PRINTF_FLAG_SHOWPLUS; break;	476	case '+': flags \|= __PRINTF_FLAG_SHOWPLUS; break;
477	case ' ': flags \|= __PRINTF_FLAG_SPACESIGN; break;	477	case ' ': flags \|= __PRINTF_FLAG_SPACESIGN; break;
478	case '0': flags \|= __PRINTF_FLAG_ZEROPADDED; break;	478	case '0': flags \|= __PRINTF_FLAG_ZEROPADDED; break;
479	default: end = 1;	479	default: end = 1;
480	};	480	};
481		481
482	} while (end == 0);	482	} while (end == 0);
483		483
484	/* width & '' operator /	484	/* width & '' operator /
485	width = 0;	485	width = 0;
486	if (isdigit(fmt[i])) {	486	if (isdigit(fmt[i])) {
487	while (isdigit(fmt[i])) {	487	while (isdigit(fmt[i])) {
488	width *= 10;	488	width *= 10;
489	width += fmt[i++] - '0';	489	width += fmt[i++] - '0';
490	}	490	}
491	} else if (fmt[i] == '*') {	491	} else if (fmt[i] == '*') {
492	/* get width value from argument list*/	492	/* get width value from argument list*/
493	i++;	493	i++;
494	width = (int)va_arg(ap, int);	494	width = (int)va_arg(ap, int);
495	if (width < 0) {	495	if (width < 0) {
496	/* negative width means to set '-' flag */	496	/* negative width means to set '-' flag */
497	width *= -1;	497	width *= -1;
498	flags \|= __PRINTF_FLAG_LEFTALIGNED;	498	flags \|= __PRINTF_FLAG_LEFTALIGNED;
499	}	499	}
500	}	500	}

Subversion Repositories HelenOS

(root)/trunk/uspace/libc/generic/io/printf_core.c – Rev 2070 → 2071