printf_core.c

Go to the documentation of this file.

/*
 * Copyright (c) 2001-2004 Jakub Jermar
 * Copyright (c) 2006 Josef Cejka
 * Copyright (c) 2009 Martin Decky
 * All rights reserved.
 *
 * Redistribution and use in source and binary forms, with or without
 * modification, are permitted provided that the following conditions
 * are met:
 *
 * - Redistributions of source code must retain the above copyright
 *   notice, this list of conditions and the following disclaimer.
 * - Redistributions in binary form must reproduce the above copyright
 *   notice, this list of conditions and the following disclaimer in the
 *   documentation and/or other materials provided with the distribution.
 * - The name of the author may not be used to endorse or promote products
 *   derived from this software without specific prior written permission.
 *
 * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR
 * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
 * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
 * IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT,
 * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
 * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
 * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
 * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
 * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
 * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 */

#include <unistd.h>
#include <stdio.h>
#include <io/printf_core.h>
#include <ctype.h>
#include <str.h>

#define __PRINTF_FLAG_PREFIX       0x00000001

#define __PRINTF_FLAG_SIGNED       0x00000002

#define __PRINTF_FLAG_ZEROPADDED   0x00000004

#define __PRINTF_FLAG_LEFTALIGNED  0x00000010

#define __PRINTF_FLAG_SHOWPLUS     0x00000020

#define __PRINTF_FLAG_SPACESIGN    0x00000040

#define __PRINTF_FLAG_BIGCHARS     0x00000080

#define __PRINTF_FLAG_NEGATIVE     0x00000100

#define PRINT_NUMBER_BUFFER_SIZE  (64 + 5)

typedef enum {
        PrintfQualifierByte = 0,
        PrintfQualifierShort,
        PrintfQualifierInt,
        PrintfQualifierLong,
        PrintfQualifierLongLong,
        PrintfQualifierPointer,
        PrintfQualifierSize
} qualifier_t;

static const char *nullstr = "(NULL)";
static const char *digits_small = "0123456789abcdef";
static const char *digits_big = "0123456789ABCDEF";
static const char invalch = U_SPECIAL;

static int printf_putnchars(const char *buf, size_t size,
    printf_spec_t *ps)
{
        return ps->str_write((void *) buf, size, ps->data);
}

static int printf_wputnchars(const wchar_t *buf, size_t size,
    printf_spec_t *ps)
{
        return ps->wstr_write((void *) buf, size, ps->data);
}

static int printf_putstr(const char *str, printf_spec_t *ps)
{
        if (str == NULL)
                return printf_putnchars(nullstr, str_size(nullstr), ps);
        
        return ps->str_write((void *) str, str_size(str), ps->data);
}

static int printf_putchar(const char ch, printf_spec_t *ps)
{
        if (!ascii_check(ch))
                return ps->str_write((void *) &invalch, 1, ps->data);
        
        return ps->str_write(&ch, 1, ps->data);
}

static int printf_putwchar(const wchar_t ch, printf_spec_t *ps)
{
        if (!chr_check(ch))
                return ps->str_write((void *) &invalch, 1, ps->data);
        
        return ps->wstr_write(&ch, sizeof(wchar_t), ps->data);
}

static int print_char(const char ch, int width, uint32_t flags, printf_spec_t *ps)
{
        size_t counter = 0;
        if (!(flags & __PRINTF_FLAG_LEFTALIGNED)) {
                while (--width > 0) {
                        /*
                         * One space is consumed by the character itself, hence
                         * the predecrement.
                         */
                        if (printf_putchar(' ', ps) > 0)
                                counter++;
                }
        }
        
        if (printf_putchar(ch, ps) > 0)
                counter++;
        
        while (--width > 0) {
                /*
                 * One space is consumed by the character itself, hence
                 * the predecrement.
                 */
                if (printf_putchar(' ', ps) > 0)
                        counter++;
        }
        
        return (int) (counter + 1);
}

static int print_wchar(const wchar_t ch, int width, uint32_t flags, printf_spec_t *ps)
{
        size_t counter = 0;
        if (!(flags & __PRINTF_FLAG_LEFTALIGNED)) {
                while (--width > 0) {
                        /*
                         * One space is consumed by the character itself, hence
                         * the predecrement.
                         */
                        if (printf_putchar(' ', ps) > 0)
                                counter++;
                }
        }
        
        if (printf_putwchar(ch, ps) > 0)
                counter++;
        
        while (--width > 0) {
                /*
                 * One space is consumed by the character itself, hence
                 * the predecrement.
                 */
                if (printf_putchar(' ', ps) > 0)
                        counter++;
        }
        
        return (int) (counter + 1);
}

static int print_str(char *str, int width, unsigned int precision,
    uint32_t flags, printf_spec_t *ps)
{
        if (str == NULL)
                return printf_putstr(nullstr, ps);
        
        /* Print leading spaces. */
        size_t strw = str_length(str);
        if (precision == 0)
                precision = strw;
        
        /* Left padding */
        size_t counter = 0;
        width -= precision;
        if (!(flags & __PRINTF_FLAG_LEFTALIGNED)) {
                while (width-- > 0) {
                        if (printf_putchar(' ', ps) == 1)
                                counter++;
                }
        }
        
        /* Part of @a str fitting into the alloted space. */
        int retval;
        size_t size = str_lsize(str, precision);
        if ((retval = printf_putnchars(str, size, ps)) < 0)
                return -counter;

        counter += retval;

        /* Right padding */
        while (width-- > 0) {
                if (printf_putchar(' ', ps) == 1)
                        counter++;
        }

        return ((int) counter);

}

static int print_wstr(wchar_t *str, int width, unsigned int precision,
    uint32_t flags, printf_spec_t *ps)
{
        if (str == NULL)
                return printf_putstr(nullstr, ps);
        
        /* Print leading spaces. */
        size_t strw = wstr_length(str);
        if (precision == 0)
                precision = strw;
        
        /* Left padding */
        size_t counter = 0;
        width -= precision;
        if (!(flags & __PRINTF_FLAG_LEFTALIGNED)) {
                while (width-- > 0) {
                        if (printf_putchar(' ', ps) == 1)
                                counter++;
                }
        }
        
        /* Part of @a wstr fitting into the alloted space. */
        int retval;
        size_t size = wstr_lsize(str, precision);
        if ((retval = printf_wputnchars(str, size, ps)) < 0)
                return -counter;
        
        counter += retval;
        
        /* Right padding */
        while (width-- > 0) {
                if (printf_putchar(' ', ps) == 1)
                        counter++;
        }

        return ((int) counter);
}

static int print_number(uint64_t num, int width, int precision, int base,
    uint32_t flags, printf_spec_t *ps)
{
        const char *digits;
        if (flags & __PRINTF_FLAG_BIGCHARS)
                digits = digits_big;
        else
                digits = digits_small;
        
        char data[PRINT_NUMBER_BUFFER_SIZE];
        char *ptr = &data[PRINT_NUMBER_BUFFER_SIZE - 1];
        
        /* Size of number with all prefixes and signs */
        int size = 0;
        
        /* Put zero at end of string */
        *ptr-- = 0;
        
        if (num == 0) {
                *ptr-- = '0';
                size++;
        } else {
                do {
                        *ptr-- = digits[num % base];
                        size++;
                } while (num /= base);
        }
        
        /* Size of plain number */
        int number_size = size;
        
        /*
         * Collect the sum of all prefixes/signs/etc. to calculate padding and
         * leading zeroes.
         */
        if (flags & __PRINTF_FLAG_PREFIX) {
                switch (base) {
                case 2:
                        /* Binary formating is not standard, but usefull */
                        size += 2;
                        break;
                case 8:
                        size++;
                        break;
                case 16:
                        size += 2;
                        break;
                }
        }
        
        char sgn = 0;
        if (flags & __PRINTF_FLAG_SIGNED) {
                if (flags & __PRINTF_FLAG_NEGATIVE) {
                        sgn = '-';
                        size++;
                } else if (flags & __PRINTF_FLAG_SHOWPLUS) {
                        sgn = '+';
                        size++;
                } else if (flags & __PRINTF_FLAG_SPACESIGN) {
                        sgn = ' ';
                        size++;
                }
        }
        
        if (flags & __PRINTF_FLAG_LEFTALIGNED)
                flags &= ~__PRINTF_FLAG_ZEROPADDED;
        
        /*
         * If the number is left-aligned or precision is specified then
         * padding with zeros is ignored.
         */
        if (flags & __PRINTF_FLAG_ZEROPADDED) {
                if ((precision == 0) && (width > size))
                        precision = width - size + number_size;
        }
        
        /* Print leading spaces */
        if (number_size > precision) {
                /* Print the whole number, not only a part */
                precision = number_size;
        }
        
        width -= precision + size - number_size;
        size_t counter = 0;
        
        if (!(flags & __PRINTF_FLAG_LEFTALIGNED)) {
                while (width-- > 0) {
                        if (printf_putchar(' ', ps) == 1)
                                counter++;
                }
        }
        
        /* Print sign */
        if (sgn) {
                if (printf_putchar(sgn, ps) == 1)
                        counter++;
        }
        
        /* Print prefix */
        if (flags & __PRINTF_FLAG_PREFIX) {
                switch (base) {
                case 2:
                        /* Binary formating is not standard, but usefull */
                        if (printf_putchar('0', ps) == 1)
                                counter++;
                        if (flags & __PRINTF_FLAG_BIGCHARS) {
                                if (printf_putchar('B', ps) == 1)
                                        counter++;
                        } else {
                                if (printf_putchar('b', ps) == 1)
                                        counter++;
                        }
                        break;
                case 8:
                        if (printf_putchar('o', ps) == 1)
                                counter++;
                        break;
                case 16:
                        if (printf_putchar('0', ps) == 1)
                                counter++;
                        if (flags & __PRINTF_FLAG_BIGCHARS) {
                                if (printf_putchar('X', ps) == 1)
                                        counter++;
                        } else {
                                if (printf_putchar('x', ps) == 1)
                                        counter++;
                        }
                        break;
                }
        }
        
        /* Print leading zeroes */
        precision -= number_size;
        while (precision-- > 0) {
                if (printf_putchar('0', ps) == 1)
                        counter++;
        }
        
        /* Print the number itself */
        int retval;
        if ((retval = printf_putstr(++ptr, ps)) > 0)
                counter += retval;
        
        /* Print trailing spaces */
        
        while (width-- > 0) {
                if (printf_putchar(' ', ps) == 1)
                        counter++;
        }
        
        return ((int) counter);
}

int printf_core(const char *fmt, printf_spec_t *ps, va_list ap)
{
        size_t i;        /* Index of the currently processed character from fmt */
        size_t nxt = 0;  /* Index of the next character from fmt */
        size_t j = 0;    /* Index to the first not printed nonformating character */
        
        size_t counter = 0;   /* Number of characters printed */
        int retval;           /* Return values from nested functions */
        
        while (true) {
                i = nxt;
                wchar_t uc = str_decode(fmt, &nxt, STR_NO_LIMIT);
                
                if (uc == 0)
                        break;
                
                /* Control character */
                if (uc == '%') {
                        /* Print common characters if any processed */
                        if (i > j) {
                                if ((retval = printf_putnchars(&fmt[j], i - j, ps)) < 0) {
                                        /* Error */
                                        counter = -counter;
                                        goto out;
                                }
                                counter += retval;
                        }
                        
                        j = i;
                        
                        /* Parse modifiers */
                        uint32_t flags = 0;
                        bool end = false;
                        
                        do {
                                i = nxt;
                                uc = str_decode(fmt, &nxt, STR_NO_LIMIT);
                                switch (uc) {
                                case '#':
                                        flags |= __PRINTF_FLAG_PREFIX;
                                        break;
                                case '-':
                                        flags |= __PRINTF_FLAG_LEFTALIGNED;
                                        break;
                                case '+':
                                        flags |= __PRINTF_FLAG_SHOWPLUS;
                                        break;
                                case ' ':
                                        flags |= __PRINTF_FLAG_SPACESIGN;
                                        break;
                                case '0':
                                        flags |= __PRINTF_FLAG_ZEROPADDED;
                                        break;
                                default:
                                        end = true;
                                };
                        } while (!end);
                        
                        /* Width & '*' operator */
                        int width = 0;
                        if (isdigit(uc)) {
                                while (true) {
                                        width *= 10;
                                        width += uc - '0';
                                        
                                        i = nxt;
                                        uc = str_decode(fmt, &nxt, STR_NO_LIMIT);
                                        if (uc == 0)
                                                break;
                                        if (!isdigit(uc))
                                                break;
                                }
                        } else if (uc == '*') {
                                /* Get width value from argument list */
                                i = nxt;
                                uc = str_decode(fmt, &nxt, STR_NO_LIMIT);
                                width = (int) va_arg(ap, int);
                                if (width < 0) {
                                        /* Negative width sets '-' flag */
                                        width *= -1;
                                        flags |= __PRINTF_FLAG_LEFTALIGNED;
                                }
                        }
                        
                        /* Precision and '*' operator */
                        int precision = 0;
                        if (uc == '.') {
                                i = nxt;
                                uc = str_decode(fmt, &nxt, STR_NO_LIMIT);
                                if (isdigit(uc)) {
                                        while (true) {
                                                precision *= 10;
                                                precision += uc - '0';
                                                
                                                i = nxt;
                                                uc = str_decode(fmt, &nxt, STR_NO_LIMIT);
                                                if (uc == 0)
                                                        break;
                                                if (!isdigit(uc))
                                                        break;
                                        }
                                } else if (uc == '*') {
                                        /* Get precision value from the argument list */
                                        i = nxt;
                                        uc = str_decode(fmt, &nxt, STR_NO_LIMIT);
                                        precision = (int) va_arg(ap, int);
                                        if (precision < 0) {
                                                /* Ignore negative precision */
                                                precision = 0;
                                        }
                                }
                        }
                        
                        qualifier_t qualifier;
                        
                        switch (uc) {
                        case 'h':
                                /* Char or short */
                                qualifier = PrintfQualifierShort;
                                i = nxt;
                                uc = str_decode(fmt, &nxt, STR_NO_LIMIT);
                                if (uc == 'h') {
                                        i = nxt;
                                        uc = str_decode(fmt, &nxt, STR_NO_LIMIT);
                                        qualifier = PrintfQualifierByte;
                                }
                                break;
                        case 'l':
                                /* Long or long long */
                                qualifier = PrintfQualifierLong;
                                i = nxt;
                                uc = str_decode(fmt, &nxt, STR_NO_LIMIT);
                                if (uc == 'l') {
                                        i = nxt;
                                        uc = str_decode(fmt, &nxt, STR_NO_LIMIT);
                                        qualifier = PrintfQualifierLongLong;
                                }
                                break;
                        case 'z':
                                qualifier = PrintfQualifierSize;
                                i = nxt;
                                uc = str_decode(fmt, &nxt, STR_NO_LIMIT);
                                break;
                        default:
                                /* Default type */
                                qualifier = PrintfQualifierInt;
                        }
                        
                        unsigned int base = 10;
                        
                        switch (uc) {
                        /*
                         * String and character conversions.
                         */
                        case 's':
                                if (qualifier == PrintfQualifierLong)
                                        retval = print_wstr(va_arg(ap, wchar_t *), width, precision, flags, ps);
                                else
                                        retval = print_str(va_arg(ap, char *), width, precision, flags, ps);
                                
                                if (retval < 0) {
                                        counter = -counter;
                                        goto out;
                                }
                                
                                counter += retval;
                                j = nxt;
                                goto next_char;
                        case 'c':
                                if (qualifier == PrintfQualifierLong)
                                        retval = print_wchar(va_arg(ap, wint_t), width, flags, ps);
                                else
                                        retval = print_char(va_arg(ap, unsigned int), width, flags, ps);
                                
                                if (retval < 0) {
                                        counter = -counter;
                                        goto out;
                                };
                                
                                counter += retval;
                                j = nxt;
                                goto next_char;
                        
                        /*
                         * Integer values
                         */
                        case 'P':
                                /* Pointer */
                                flags |= __PRINTF_FLAG_BIGCHARS;
                        case 'p':
                                flags |= __PRINTF_FLAG_PREFIX;
                                flags |= __PRINTF_FLAG_ZEROPADDED;
                                base = 16;
                                qualifier = PrintfQualifierPointer;
                                break;
                        case 'b':
                                base = 2;
                                break;
                        case 'o':
                                base = 8;
                                break;
                        case 'd':
                        case 'i':
                                flags |= __PRINTF_FLAG_SIGNED;
                        case 'u':
                                break;
                        case 'X':
                                flags |= __PRINTF_FLAG_BIGCHARS;
                        case 'x':
                                base = 16;
                                break;
                        
                        /* Percentile itself */
                        case '%':
                                j = i;
                                goto next_char;
                        
                        /*
                         * Bad formatting.
                         */
                        default:
                                /*
                                 * Unknown format. Now, j is the index of '%'
                                 * so we will print whole bad format sequence.
                                 */
                                goto next_char;
                        }
                        
                        /* Print integers */
                        size_t size;
                        uint64_t number;
                        switch (qualifier) {
                        case PrintfQualifierByte:
                                size = sizeof(unsigned char);
                                number = (uint64_t) va_arg(ap, unsigned int);
                                break;
                        case PrintfQualifierShort:
                                size = sizeof(unsigned short);
                                number = (uint64_t) va_arg(ap, unsigned int);
                                break;
                        case PrintfQualifierInt:
                                size = sizeof(unsigned int);
                                number = (uint64_t) va_arg(ap, unsigned int);
                                break;
                        case PrintfQualifierLong:
                                size = sizeof(unsigned long);
                                number = (uint64_t) va_arg(ap, unsigned long);
                                break;
                        case PrintfQualifierLongLong:
                                size = sizeof(unsigned long long);
                                number = (uint64_t) va_arg(ap, unsigned long long);
                                break;
                        case PrintfQualifierPointer:
                                size = sizeof(void *);
                                precision = size << 1;
                                number = (uint64_t) (uintptr_t) va_arg(ap, void *);
                                break;
                        case PrintfQualifierSize:
                                size = sizeof(size_t);
                                number = (uint64_t) va_arg(ap, size_t);
                                break;
                        default:
                                /* Unknown qualifier */
                                counter = -counter;
                                goto out;
                        }
                        
                        if (flags & __PRINTF_FLAG_SIGNED) {
                                if (number & (0x1 << (size * 8 - 1))) {
                                        flags |= __PRINTF_FLAG_NEGATIVE;
                                        
                                        if (size == sizeof(uint64_t)) {
                                                number = -((int64_t) number);
                                        } else {
                                                number = ~number;
                                                number &=
                                                    ~(0xFFFFFFFFFFFFFFFFll <<
                                                    (size * 8));
                                                number++;
                                        }
                                }
                        }
                        
                        if ((retval = print_number(number, width, precision,
                            base, flags, ps)) < 0) {
                                counter = -counter;
                                goto out;
                        }
                        
                        counter += retval;
                        j = nxt;
                }
next_char:
                ;
        }
        
        if (i > j) {
                if ((retval = printf_putnchars(&fmt[j], i - j, ps)) < 0) {
                        /* Error */
                        counter = -counter;
                        goto out;
                }
                counter += retval;
        }
        
out:
        return ((int) counter);
}

---