WebSVN – HelenOS – Diff – /branches/arm/uspace/lib/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>
 
#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);
 
    count = strlen(str);
 
    return ps->write((void *) str, count, ps->data);
}
 
/** 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)) {
        /*
         * One space is consumed by the character itself, hence the
         * predecrement.
         */
        while (--width > 0) {
            if (printf_putchar(' ', ps) > 0)   
                ++counter;
        }
    }
   
    if (printf_putchar(c, ps) > 0)
        counter++;
    /*
     * One space is consumed by the character itself, hence the
     * predecrement.
     */
    while (--width > 0) {
        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++;
        }
    }
 
    if ((retval = printf_putnchars(s, size < precision ? size : 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 */
 
    /* We must print whole number not only a part. */
    if (number_size > precision)
        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)
{
    /* i is the index of the currently processed char from fmt */
    int i = 0;
    /* j is the index to the first not printed nonformating character */
    int j = 0;
 
    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 a numeric parameter printed */
    uint64_t number; /* argument value */
    size_t  size;   /* byte size of integer parameter */
    int width, precision;
    uint64_t flags;
   
    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 sets '-' 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 */
                    i++;
                    precision = (int)va_arg(ap, int);
                    if (precision < 0) {
                        /* negative precision ignored */
                        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:
                /* set default type */
                qualifier = PrintfQualifierInt;
                --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);
                retval = print_char(c, width, flags, ps);
                if (retval < 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, j is the index of '%',
                 * so we will print the whole bad format
                 * sequence.
                 */
                goto next_char;    
            }
       
       
            /* Print integers */
            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) {
        retval = printf_putnchars(&fmt[j], (size_t)(i - j), ps);
        if (retval < 0) { /* error */
            goto minus_out;
        }
        counter += retval;
    }
   
    return counter;
minus_out:
    return -counter;
}
 
/** @}
 */
 

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

Subversion Repositories HelenOS

(root)/branches/arm/uspace/lib/libc/generic/io/printf_core.c – Rev 3347 → 3478