Context Navigation

-              r74c8da2c
+              reec616b
  * Copyright (c) 2001-2004 Jakub Jermar
  * Copyright (c) 2006 Josef Cejka
+ * Copyright (c) 2009 Martin Decky
  * All rights reserved.
+ *
 …
  */
 /** @addtogroup generic
+/** @addtogroup generic
  * @{
  */
 /**
  * @file
  * @brief       Printing functions.
+ * @brief Printing functions.
  */
 #include <printf/printf_core.h>
-#include <putchar.h>
 #include <print.h>
 #include <arch/arg.h>
 …
 /** show prefixes 0x or 0 */
 #define __PRINTF_FLAG_PREFIX            0x00000001
+#define __PRINTF_FLAG_PREFIX       0x00000001
 /** signed / unsigned number */
 #define __PRINTF_FLAG_SIGNED            0x00000002
+#define __PRINTF_FLAG_SIGNED       0x00000002
 /** print leading zeroes */
 #define __PRINTF_FLAG_ZEROPADDED        0x00000004
+#define __PRINTF_FLAG_ZEROPADDED   0x00000004
 /** align to left */
 #define __PRINTF_FLAG_LEFTALIGNED       0x00000010
+#define __PRINTF_FLAG_LEFTALIGNED  0x00000010
 /** always show + sign */
 #define __PRINTF_FLAG_SHOWPLUS          0x00000020
+#define __PRINTF_FLAG_SHOWPLUS     0x00000020
 /** print space instead of plus */
 #define __PRINTF_FLAG_SPACESIGN         0x00000040
+#define __PRINTF_FLAG_SPACESIGN    0x00000040
 /** show big characters */
 #define __PRINTF_FLAG_BIGCHARS          0x00000080
+#define __PRINTF_FLAG_BIGCHARS     0x00000080
 /** number has - sign */
 #define __PRINTF_FLAG_NEGATIVE          0x00000100
+#define __PRINTF_FLAG_NEGATIVE     0x00000100
 /**
 …
  * zero-filling subroutine)
  */
 #define PRINT_NUMBER_BUFFER_SIZE        (64 + 5)
+#define PRINT_NUMBER_BUFFER_SIZE  (64 + 5)
 /** Enumeration of possible arguments types.
 …
 } qualifier_t;
+static char nullstr[] = "(NULL)";
 static char digits_small[] = "0123456789abcdef";
 static char digits_big[] = "0123456789ABCDEF";
+/** Print one or more characters without adding newline.
+ *
+ * @param buf           Buffer with size at least count bytes. NULL pointer is
+ *                      not allowed!
+ * @param count         Number of characters to print.
+ * @param ps            Output method and its data.
+ * @return              Number of characters printed.
+ */
+static int printf_putnchars(const char * buf, size_t count,
+    struct printf_spec *ps)
+{
+        return ps->write((void *) buf, count, ps->data);
+}
+/** Print a string without adding a newline.
+ *
+ * @param str           String to print.
+ * @param ps            Write function specification and support data.
+ * @return              Number of characters printed.
+ */
+static int printf_putstr(const char * str, struct printf_spec *ps)
+{
+        size_t count;
+        if (str == NULL) {
+                char *nullstr = "(NULL)";
+                return printf_putnchars(nullstr, strlen(nullstr), ps);
+        }
+        count = strlen(str);
+        return ps->write((void *) str, count, ps->data);
+}
+/** Print one character.
+ *
+ * @param c             Character to be printed.
+ * @param ps            Output method.
+ *
+ * @return              Number of characters printed.
+ */
+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         Width modifier.
+ * @param flags         Flags that change the way the character is printed.
+ *
+ * @return              Number of characters printed, negative value on failure.
+ */
+static int print_char(char c, int width, uint64_t flags, struct printf_spec *ps)
+{
+        int counter = 0;
+/** Print one or more UTF-8 characters without adding newline.
+ *
+ * @param buf  Buffer holding UTF-8 characters with size of
+ *             at least size bytes. NULL is not allowed!
+ * @param size Size of the buffer in bytes.
+ * @param ps   Output method and its data.
+ *
+ * @return Number of UTF-8 characters printed.
+ *
+ */
+static int printf_putnchars_utf8(const char *buf, size_t size,
+    printf_spec_t *ps)
+{
+        return ps->write_utf8((void *) buf, size, ps->data);
+}
+/** Print one or more UTF-32 characters without adding newline.
+ *
+ * @param buf  Buffer holding UTF-32 characters with size of
+ *             at least size bytes. NULL is not allowed!
+ * @param size Size of the buffer in bytes.
+ * @param ps   Output method and its data.
+ *
+ * @return Number of UTF-32 characters printed.
+ *
+ */
+static int printf_putnchars_utf32(const wchar_t *buf, size_t size,
+    printf_spec_t *ps)
+{
+        return ps->write_utf32((void *) buf, size, ps->data);
+}
+/** Print UTF-8 string without adding a newline.
+ *
+ * @param str UTF-8 string to print.
+ * @param ps  Write function specification and support data.
+ *
+ * @return Number of UTF-8 characters printed.
+ *
+ */
+static int printf_putstr(const char *str, printf_spec_t *ps)
+{
+        if (str == NULL)
+                return printf_putnchars_utf8(nullstr, strlen(nullstr), ps);
+        return ps->write_utf8((void *) str, strlen(str), ps->data);
+}
+/** Print one ASCII character.
+ *
+ * @param c  ASCII character to be printed.
+ * @param ps Output method.
+ *
+ * @return Number of characters printed.
+ *
+ */
+static int printf_putchar(const char ch, printf_spec_t *ps)
+{
+        if (!ascii_check(ch))
+                return ps->write_utf8((void *) &invalch, 1, ps->data);
+        return ps->write_utf8(&ch, 1, ps->data);
+}
+/** Print one UTF-32 character.
+ *
+ * @param c  UTF-32 character to be printed.
+ * @param ps Output method.
+ *
+ * @return Number of characters printed.
+ *
+ */
+static int printf_putwchar(const wchar_t ch, printf_spec_t *ps)
+{
+        if (!unicode_check(ch))
+                return ps->write_utf8((void *) &invalch, 1, ps->data);
+        return ps->write_utf32(&ch, 1, ps->data);
+}
+/** Print one formatted ASCII character.
+ *
+ * @param ch    Character to print.
+ * @param width Width modifier.
+ * @param flags Flags that change the way the character is printed.
+ *
+ * @return Number of characters printed, negative value on failure.
+ *
+ */
+static int print_char(const char ch, int width, uint32_t flags, printf_spec_t *ps)
+{
+        count_t counter = 0;
         if (!(flags & __PRINTF_FLAG_LEFTALIGNED)) {
                 while (--width > 0) {
 …
                          * the predecrement.
                          */
                         if (printf_putchar(' ', ps) > 0)
                                 ++counter;
+                }
+        }
         if (printf_putchar(c, ps) > 0)
+                        if (printf_putchar(' ', ps) > 0)
+                                counter++;
+                }
+        }
+        if (printf_putchar(ch, ps) > 0)
                 counter++;
         while (--width > 0) {
+                /*
+                 * One space is consumed by the character itself, hence
+                 * the predecrement.
+                 */
+                if (printf_putchar(' ', ps) > 0)
+                        counter++;
+        }
+        return (int) (counter + 1);
+}
+/** Print one formatted UTF-32 character.
+ *
+ * @param ch    Character to print.
+ * @param width Width modifier.
+ * @param flags Flags that change the way the character is printed.
+ *
+ * @return Number of characters printed, negative value on failure.
+ *
+ */
+static int print_wchar(const wchar_t ch, int width, uint32_t flags, printf_spec_t *ps)
+{
+        count_t counter = 0;
+        if (!(flags & __PRINTF_FLAG_LEFTALIGNED)) {
+                while (--width > 0) {
                         /*
                          * One space is consumed by the character itself, hence
                          * the predecrement.
                          */
+                        if (printf_putchar(' ', ps) > 0)
+                                counter++;
+                }
+        }
+        if (printf_putwchar(ch, ps) > 0)
+                counter++;
+        while (--width > 0) {
+                /*
+                 * One space is consumed by the character itself, hence
+                 * the predecrement.
+                 */
                 if (printf_putchar(' ', ps) > 0)
+                        ++counter;
+        }
+        return ++counter;
+}
+/** Print string.
+ *
+ * @param s             String to be printed.
+ * @param width         Width modifier.
+ * @param precision     Precision modifier.
+ * @param flags         Flags that modify the way the string is printed.
+ *
+ * @return              Number of characters printed, negative value on failure.
+ */
+static int print_string(char *s, int width, unsigned int precision,
+        uint64_t flags, struct printf_spec *ps)
+{
+        int counter = 0;
+        size_t size;
+                        counter++;
+        }
+        return (int) (counter + 1);
+}
+/** Print UTF-8 string.
+ *
+ * @param str       UTF-8 string to be printed.
+ * @param width     Width modifier.
+ * @param precision Precision modifier.
+ * @param flags     Flags that modify the way the string is printed.
+ *
+ * @return Number of UTF-8 characters printed, negative value on failure.
+ */
+static int print_utf8(char *str, int width, unsigned int precision,
+        uint32_t flags, printf_spec_t *ps)
+{
+        if (str == NULL)
+                return printf_putstr(nullstr, ps);
+        /* Print leading spaces */
+        size_t size = strlen_utf8(str);
+        if (precision == 0)
+                precision = size;
+        count_t counter = 0;
+        width -= precision;
+        if (!(flags & __PRINTF_FLAG_LEFTALIGNED)) {
+                while (width-- > 0) {
+                        if (printf_putchar(' ', ps) == 1)
+                                counter++;
+                }
+        }
         int retval;
+        if (s == NULL) {
+                return printf_putstr("(NULL)", ps);
+        }
+        size = strlen(s);
+        /* print leading spaces */
+        if (precision == 0)
+        size_t bytes = utf8_count_bytes(str, min(size, precision));
+        if ((retval = printf_putnchars_utf8(str, bytes, ps)) < 0)
+                return -counter;
+        counter += retval;
+        while (width-- > 0) {
+                if (printf_putchar(' ', ps) == 1)
+                        counter++;
+        }
+        return ((int) counter);
+}
+/** Print UTF-32 string.
+ *
+ * @param str       UTF-32 string to be printed.
+ * @param width     Width modifier.
+ * @param precision Precision modifier.
+ * @param flags     Flags that modify the way the string is printed.
+ *
+ * @return Number of UTF-32 characters printed, negative value on failure.
+ */
+static int print_utf32(wchar_t *str, int width, unsigned int precision,
+        uint32_t flags, printf_spec_t *ps)
+{
+        if (str == NULL)
+                return printf_putstr(nullstr, ps);
+        /* Print leading spaces */
+        size_t size = strlen_utf32(str);
+        if (precision == 0)
                 precision = size;
+        count_t counter = 0;
         width -= precision;
         if (!(flags & __PRINTF_FLAG_LEFTALIGNED)) {
                 while (width-- > 0) {
                         if (printf_putchar(' ', ps) == 1)
+                while (width-- > 0) {
+                        if (printf_putchar(' ', ps) == 1)
                                 counter++;
+                }
+        }
+        if ((retval = printf_putnchars(s, min(size, precision), ps)) < 0) {
+        int retval;
+        size_t bytes = min(size, precision) * sizeof(wchar_t);
+        if ((retval = printf_putnchars_utf32(str, bytes, ps)) < 0)
                 return -counter;
+        }
         counter += retval;
+        counter += retval;
         while (width-- > 0) {
+                if (printf_putchar(' ', ps) == 1)
+                        ++counter;
+        }
+        return counter;
+}
+                if (printf_putchar(' ', ps) == 1)
+                        counter++;
+        }
+        return ((int) counter);
+}
 /** Print a number in a given base.
 …
  * Print significant digits of a number in given base.
+ *
  * @param num           Number to print.
  * @param widt          Width modifier.h
  * @param precision     Precision modifier.
  * @param base          Base to print the number in (must be between 2 and 16).
  * @param flags         Flags that modify the way the number is printed.
+ *
  * @return              Number of characters printed.
+ * @param num       Number to print.
+ * @param width     Width modifier.
+ * @param precision Precision modifier.
+ * @param base      Base to print the number in (must be between 2 and 16).
+ * @param flags     Flags that modify the way the number is printed.
+ *
+ * @return Number of characters printed.
+ *
  */
 static int print_number(uint64_t num, int width, int precision, int base,
+    uint64_t flags, struct printf_spec *ps)
+{
+        char *digits = digits_small;
+        char d[PRINT_NUMBER_BUFFER_SIZE];
+        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 */
+    uint32_t flags, printf_spec_t *ps)
+{
+        char *digits;
+        if (flags & __PRINTF_FLAG_BIGCHARS)
+                digits = digits_big;
+        else
+                digits = digits_small;
+        char data[PRINT_NUMBER_BUFFER_SIZE];
+        char *ptr = &data[PRINT_NUMBER_BUFFER_SIZE - 1];
+        /* Size of number with all prefixes and signs */
+        int size = 0;
+        /* Put zero at end of string */
+        *ptr-- = 0;
         if (num == 0) {
                 *ptr-- = '0';
 …
+        }
+        number_size = size;
+        /* Size of plain number */
+        int number_size = size;
         /*
          * Collect the sum of all prefixes/signs/... to calculate padding and
+         * 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 */
+                case 2:
+                        /* Binary formating is not standard, but usefull */
                         size += 2;
                         break;
 …
+                }
+        }
         sgn = 0;
+        char sgn = 0;
         if (flags & __PRINTF_FLAG_SIGNED) {
                 if (flags & __PRINTF_FLAG_NEGATIVE) {
 …
+                }
+        }
         if (flags & __PRINTF_FLAG_LEFTALIGNED) {
+        if (flags & __PRINTF_FLAG_LEFTALIGNED)
                 flags &= ~__PRINTF_FLAG_ZEROPADDED;
+        }
         /*
          * If the number is leftaligned or precision is specified then
          * zeropadding is ignored.
+         * 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)) {
+                if ((precision == 0) && (width > size))
                         precision = width - size + number_size;
+                }
+        }
+        /* print leading spaces */
+        }
+        /* Print leading spaces */
         if (number_size > precision) {
                 /* print the whole number not only a part */
+                /* Print the whole number, not only a part */
                 precision = number_size;
+        }
         width -= precision + size - number_size;
+        count_t counter = 0;
         if (!(flags & __PRINTF_FLAG_LEFTALIGNED)) {
                 while (width-- > 0) {
                         if (printf_putchar(' ', ps) == 1)
+                while (width-- > 0) {
+                        if (printf_putchar(' ', ps) == 1)
                                 counter++;
+                }
+        }
+        /* print sign */
+        /* Print sign */
         if (sgn) {
                 if (printf_putchar(sgn, ps) == 1)
 …
+        }
+        /* print prefix */
+        /* Print prefix */
         if (flags & __PRINTF_FLAG_PREFIX) {
                 switch(base) {
+                case 2: /* Binary formating is not standard, but usefull */
+                case 2:
+                        /* Binary formating is not standard, but usefull */
                         if (printf_putchar('0', ps) == 1)
                                 counter++;
 …
+                }
+        }
         /* print leading zeroes */
+        /* Print leading zeroes */
         precision -= number_size;
         while (precision-- > 0) {
+        while (precision-- > 0) {
                 if (printf_putchar('0', ps) == 1)
                         counter++;
+        }
+        /* print number itself */
+        if ((retval = printf_putstr(++ptr, ps)) > 0) {
+        /* Print the number itself */
+        int retval;
+        if ((retval = printf_putstr(++ptr, ps)) > 0)
                 counter += retval;
+        }
+        /* print ending spaces */
+        while (width-- > 0) {
+                if (printf_putchar(' ', ps) == 1)
+        /* Print tailing spaces */
+        while (width-- > 0) {
+                if (printf_putchar(' ', ps) == 1)
                         counter++;
+        }
+        return counter;
+}
+        return ((int) counter);
+}
 /** Print formatted string.
 …
  * Print string formatted according to the fmt parameter and variadic arguments.
  * Each formatting directive must have the following form:
+ *
  *      \% [ FLAGS ] [ WIDTH ] [ .PRECISION ] [ TYPE ] CONVERSION
+ *
+ *  \% [ FLAGS ] [ WIDTH ] [ .PRECISION ] [ TYPE ] CONVERSION
+ *
  * FLAGS:@n
  *      - "#"   Force to print prefix.For \%o conversion, the prefix is 0, for
  *              \%x and \%X prefixes are 0x and 0X and for conversion \%b the
  *              prefix is 0b.
+ *
  *      - "-"   Align to left.
+ *
  *      - "+"   Print positive sign just as negative.
+ *
  *      - " "   If the printed number is positive and "+" flag is not set,
  *              print space in place of sign.
+ *
  *      - "0"   Print 0 as padding instead of spaces. Zeroes are placed between
  *              sign and the rest of the number. This flag is ignored if "-"
  *              flag is specified.
+ *
+ *  - "#" Force to print prefix. For \%o conversion, the prefix is 0, for
+ *        \%x and \%X prefixes are 0x and 0X and for conversion \%b the
+ *        prefix is 0b.
+ *
+ *  - "-" Align to left.
+ *
+ *  - "+" Print positive sign just as negative.
+ *
+ *  - " " If the printed number is positive and "+" flag is not set,
+ *        print space in place of sign.
+ *
+ *  - "0" Print 0 as padding instead of spaces. Zeroes are placed between
+ *        sign and the rest of the number. This flag is ignored if "-"
+ *        flag is specified.
+ *
  * WIDTH:@n
  *      - Specify the minimal width of a printed argument. If it is bigger,
  *      width is ignored. If width is specified with a "*" character instead of
  *      number, width is taken from parameter list. And integer parameter is
  *      expected before parameter for processed conversion specification. If
  *      this value is negative its absolute value is taken and the "-" flag is
  *      set.
+ *  - Specify the minimal width of a printed argument. If it is bigger,
+ *    width is ignored. If width is specified with a "*" character instead of
+ *    number, width is taken from parameter list. And integer parameter is
+ *    expected before parameter for processed conversion specification. If
+ *    this value is negative its absolute value is taken and the "-" flag is
+ *    set.
+ *
  * PRECISION:@n
  *      - Value precision. For numbers it specifies minimum valid numbers.
  *      Smaller numbers are printed with leading zeroes. Bigger numbers are not
  *      affected. Strings with more than precision characters are cut off. Just
  *      as with width, an "*" can be used used instead of a number. An integer
  *      value is then expected in parameters. When both width and precision are
  *      specified using "*", the first parameter is used for width and the
  *      second one for precision.
+ *
+ *  - Value precision. For numbers it specifies minimum valid numbers.
+ *    Smaller numbers are printed with leading zeroes. Bigger numbers are not
+ *    affected. Strings with more than precision characters are cut off. Just
+ *    as with width, an "*" can be used used instead of a number. An integer
+ *    value is then expected in parameters. When both width and precision are
+ *    specified using "*", the first parameter is used for width and the
+ *    second one for precision.
+ *
  * TYPE:@n
+ *      - "hh"  Signed or unsigned char.@n
+ *      - "h"   Signed or unsigned short.@n
+ *      - ""    Signed or unsigned int (default value).@n
+ *      - "l"   Signed or unsigned long int.@n
+ *      - "ll"  Signed or unsigned long long int.@n
+ *
+ *
+ *  - "hh" Signed or unsigned char.@n
+ *  - "h"  Signed or unsigned short.@n
+ *  - ""   Signed or unsigned int (default value).@n
+ *  - "l"  Signed or unsigned long int.@n
+ *         If conversion is "c", the character is wchar_t (UTF-32).@n
+ *         If conversion is "s", the string is wchar_t * (UTF-32).@n
+ *  - "ll" Signed or unsigned long long int.@n
+ *
  * CONVERSION:@n
+ *      - %     Print percentile character itself.
+ *
+ *      - c     Print single character.
+ *
+ *      - 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 / \%#x
+ *              for 32-bit or \%#X / \%#x for 64-bit long pointers).
+ *
+ *      - b     Print value as unsigned binary number. Prefix is not printed by
+ *              default. (Nonstandard extension.)
+ *
+ *      - o     Print value as unsigned octal number. Prefix is not printed by
+ *              default.
+ *
+ *      - d, i  Print signed decimal number. There is no difference between d
+ *              and i conversion.
+ *
+ *      - u     Print unsigned decimal number.
+ *
+ *      - X, x  Print hexadecimal number with upper- or lower-case. Prefix is
+ *              not printed by default.
+ *
+ *  - % Print percentile character itself.
+ *
+ *  - c Print single character. The character is expected to be plain
+ *      ASCII (e.g. only values 0 .. 127 are valid).@n
+ *      If type is "l", then the character is expected to be UTF-32
+ *      (e.g. values 0 .. 0x10ffff are valid).
+ *
+ *  - s Print zero terminated string. If a NULL value is passed as
+ *      value, "(NULL)" is printed instead.@n
+ *      The string is expected to be correctly encoded UTF-8 (or plain
+ *      ASCII, which is a subset of UTF-8).@n
+ *      If type is "l", then the string is expected to be correctly
+ *      encoded UTF-32.
+ *
+ *  - P, p Print value of a pointer. Void * value is expected and it is
+ *         printed in hexadecimal notation with prefix (as with \%#X / \%#x
+ *         for 32-bit or \%#X / \%#x for 64-bit long pointers).
+ *
+ *  - b Print value as unsigned binary number. Prefix is not printed by
+ *      default. (Nonstandard extension.)
+ *
+ *  - o Print value as unsigned octal number. Prefix is not printed by
+ *      default.
+ *
+ *  - d, i Print signed decimal number. There is no difference between d
+ *         and i conversion.
+ *
+ *  - u Print unsigned decimal number.
+ *
+ *  - X, x Print hexadecimal number with upper- or lower-case. Prefix is
+ *         not printed by default.
+ *
  * All other characters from fmt except the formatting directives are printed in
  * verbatim.
+ *
+ * @param fmt           Formatting NULL terminated string.
+ * @return              Number of characters printed, negative value on failure.
+ */
+int printf_core(const char *fmt, struct printf_spec *ps, va_list ap)
+{
+        int i = 0; /* index of the currently processed char from fmt */
+        int j = 0; /* 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 a numeric parameter will be 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 */
+ * @param fmt Formatting NULL terminated string (UTF-8 or plain ASCII).
+ *
+ * @return Number of UTF-8 characters printed, negative value on failure.
+ *
+ */
+int printf_core(const char *fmt, printf_spec_t *ps, va_list ap)
+{
+        index_t i = 0;  /* Index of the currently processed character from fmt */
+        index_t j = 0;  /* Index to the first not printed nonformating character */
+        wchar_t uc;           /* Current UTF-32 character decoded from fmt */
+        count_t counter = 0;  /* Number of UTF-8 characters printed */
+        int retval;           /* Return values from nested functions */
+        while ((uc = utf8_decode(fmt, &i, UTF8_NO_LIMIT)) != 0) {
+                /* Control character */
+                if (uc == '%') {
+                        /* Print common characters if any processed */
                         if (i > j) {
                                 if ((retval = printf_putnchars(&fmt[j],
                                     (size_t)(i - j), ps)) < 0) { /* error */
+                                if ((retval = printf_putnchars_utf8(&fmt[j], i - j, ps)) < 0) {
+                                        /* Error */
                                         counter = -counter;
                                         goto out;
 …
                                 counter += retval;
+                        }
                         j = i;
+                        /* parse modifiers */
+                        flags = 0;
+                        end = 0;
+                        /* Parse modifiers */
+                        uint32_t flags = 0;
+                        bool end = false;
                         do {
                                 ++i;
                                 switch (c = fmt[i]) {
+                                i++;
+                                switch ((uc = utf8_decode(fmt, &i, UTF8_NO_LIMIT)) != 0) {
                                 case '#':
                                         flags |= __PRINTF_FLAG_PREFIX;
 …
                                         break;
                                 default:
+                                        end = 1;
+                                };
+                        } while (end == 0);
+                        /* width & '*' operator */
+                        width = 0;
+                        if (isdigit(fmt[i])) {
+                                while (isdigit(fmt[i])) {
+                                        end = true;
+                                };
+                        } while (!end);
+                        /* Width & '*' operator */
+                        int width = 0;
+                        if (isdigit(uc)) {
+                                while ((uc = utf8_decode(fmt, &i, UTF8_NO_LIMIT)) != 0) {
+                                        if (!isdigit(uc))
+                                                break;
                                         width *= 10;
+                                        width += fmt[i++] - '0';
+                                        width += uc - '0';
+                                        i++;
+                                }
                         } else if (fmt[i] == '*') {
                                 /* get width value from argument list */
+                        } else if (uc == '*') {
+                                /* Get width value from argument list */
                                 i++;
+                                uc = utf8_decode(fmt, &i, UTF8_NO_LIMIT);
                                 width = (int) va_arg(ap, int);
                                 if (width < 0) {
                                         /* negative width sets '-' flag */
+                                        /* 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 and '*' operator */
+                        int precision = 0;
+                        if (uc == '.') {
+                                i++;
+                                uc = utf8_decode(fmt, &i, UTF8_NO_LIMIT);
+                                if (isdigit(uc)) {
+                                        while ((uc = utf8_decode(fmt, &i, UTF8_NO_LIMIT)) != 0) {
+                                                if (!isdigit(uc))
+                                                        break;
                                                 precision *= 10;
+                                                precision += fmt[i++] - '0';
+                                                precision += uc - '0';
+                                                i++;
+                                        }
                                 } else if (fmt[i] == '*') {
+                                        /*
+                                         * Get precision value from the argument
+                                         * list.
+                                         */
+                                        /* Get precision value from the argument list */
                                         i++;
+                                        uc = utf8_decode(fmt, &i, UTF8_NO_LIMIT);
                                         precision = (int) va_arg(ap, int);
                                         if (precision < 0) {
                                                 /* ignore negative precision */
+                                                /* Ignore negative precision */
                                                 precision = 0;
+                                        }
+                                }
+                        }
+                        switch (fmt[i++]) {
+                        /** @todo unimplemented qualifiers:
+                         * t ptrdiff_t - ISO C 99
+                        qualifier_t qualifier;
+                        switch (uc) {
+                        /** @todo Unimplemented qualifiers:
+                         *        t ptrdiff_t - ISO C 99
                          */
+                        case 'h':       /* char or short */
+                        case 'h':
+                                /* Char or short */
                                 qualifier = PrintfQualifierShort;
+                                if (fmt[i] == 'h') {
+                                i++;
+                                uc = utf8_decode(fmt, &i, UTF8_NO_LIMIT);
+                                if (uc == 'h') {
                                         i++;
+                                        uc = utf8_decode(fmt, &i, UTF8_NO_LIMIT);
                                         qualifier = PrintfQualifierByte;
+                                }
                                 break;
+                        case 'l':       /* long or long long*/
+                        case 'l':
+                                /* Long or long long */
                                 qualifier = PrintfQualifierLong;
+                                if (fmt[i] == 'l') {
+                                i++;
+                                uc = utf8_decode(fmt, &i, UTF8_NO_LIMIT);
+                                if (uc == 'l') {
                                         i++;
+                                        uc = utf8_decode(fmt, &i, UTF8_NO_LIMIT);
                                         qualifier = PrintfQualifierLongLong;
+                                }
                                 break;
                         default:
+                                /* default type */
+                                qualifier = PrintfQualifierInt;
+                                --i;
+                        }
+                        base = 10;
+                        switch (c = fmt[i]) {
+                                /* Default type */
+                                qualifier = PrintfQualifierInt;
+                        }
+                        unsigned int base = 10;
+                        switch (uc) {
                         /*
                         * String and character conversions.
                         */
+                         * String and character conversions.
+                         */
                         case 's':
+                                if ((retval = print_string(va_arg(ap, char *),
+                                    width, precision, flags, ps)) < 0) {
+                                if (qualifier == PrintfQualifierLong)
+                                        retval = print_utf32(va_arg(ap, wchar_t *), width, precision, flags, ps);
+                                else
+                                        retval = print_utf8(va_arg(ap, char *), width, precision, flags, ps);
+                                if (retval < 0) {
                                         counter = -counter;
                                         goto out;
                                 };
+                                }
                                 counter += retval;
                                 j = i + 1;
+                                j = i + 1;
                                 goto next_char;
                         case 'c':
+                                c = va_arg(ap, unsigned int);
+                                retval = print_char(c, width, flags, ps);
+                                if (qualifier == PrintfQualifierLong)
+                                        retval = print_wchar(va_arg(ap, wchar_t), width, flags, ps);
+                                else
+                                        retval = print_char(va_arg(ap, unsigned int), width, flags, ps);
                                 if (retval < 0) {
                                         counter = -counter;
                                         goto out;
                                 };
                                 counter += retval;
                                 j = i + 1;
                                 goto next_char;
                         /*
+                        /*
                          * Integer values
                          */
+                        case 'P': /* pointer */
+                        case 'P':
+                                /* Pointer */
                                 flags |= __PRINTF_FLAG_BIGCHARS;
                         case 'p':
 …
                                 base = 16;
                                 qualifier = PrintfQualifierPointer;
                                 break;
                         case 'b':
+                                break;
+                        case 'b':
                                 base = 2;
                                 break;
 …
                         case 'd':
                         case 'i':
                                 flags |= __PRINTF_FLAG_SIGNED;
+                                flags |= __PRINTF_FLAG_SIGNED;
                         case 'u':
                                 break;
 …
                                 base = 16;
                                 break;
+                        /* percentile itself */
+                        case '%':
+                        /* Percentile itself */
+                        case '%':
                                 j = i;
                                 goto next_char;
                         /*
                          * Bad formatting.
 …
                                  * so we will print whole bad format sequence.
                                  */
                                 goto next_char;
+                        }
                 /* Print integers */
                         /* print number */
+                                goto next_char;
+                        }
+                        /* Print integers */
+                        size_t size;
+                        uint64_t number;
                         switch (qualifier) {
                         case PrintfQualifierByte:
 …
                                 number = (uint64_t) (unsigned long) va_arg(ap, void *);
                                 break;
+                        default: /* Unknown qualifier */
+                        default:
+                                /* Unknown qualifier */
                                 counter = -counter;
                                 goto out;
 …
                                 if (number & (0x1 << (size * 8 - 1))) {
                                         flags |= __PRINTF_FLAG_NEGATIVE;
                                         if (size == sizeof(uint64_t)) {
                                                 number = -((int64_t) number);
 …
+                                }
+                        }
                         if ((retval = print_number(number, width, precision,
                             base, flags, ps)) < 0) {
 …
                                 goto out;
+                        }
                         counter += retval;
                         j = i + 1;
+                }
+                }
 next_char:
                 ++i;
+                i++;
+        }
         if (i > j) {
                 if ((retval = printf_putnchars(&fmt[j], (unative_t) (i - j),
                     ps)) < 0) { /* error */
+                if ((retval = printf_putnchars_utf8(&fmt[j], i - j, ps)) < 0) {
+                        /* Error */
                         counter = -counter;
                         goto out;
+                }
                 counter += retval;
+        }
 out:
         return counter;
+        return ((int) counter);
+}

Note: See TracChangeset for help on using the changeset viewer.

Context Navigation

Changeset eec616b in mainline for kernel/generic/src/printf/printf_core.c

Legend:

kernel/generic/src/printf/printf_core.c

Download in other formats: