WebSVN – HelenOS – Diff – //branches/network/uspace/lib/libc/generic/io/printf_core.c

 /*
  * Copyright (c) 2001-2004 Jakub Jermar
  * Copyright (c) 2006 Josef Cejka
+ * Copyright (c) 2009 Martin Decky
  * All rights reserved.
+ *
  * Redistribution and use in source and binary forms, with or without
  * modification, are permitted provided that the following conditions
  * are met:
  * 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
+/** @addtogroup generic
  * @{
  */
 /**
  * @file
- * @brief   Printing functions.
+ * @brief Printing functions.
  */
 #include <unistd.h>
 #include <stdio.h>
 #include <io/printf_core.h>
 #include <ctype.h>
 #include <string.h>
+/** show prefixes 0x or 0 */
-#define __PRINTF_FLAG_PREFIX        0x00000001  /**< show prefixes 0x or 0*/
+#define __PRINTF_FLAG_PREFIX       0x00000001
+/** signed / unsigned number */
-#define __PRINTF_FLAG_SIGNED        0x00000002  /**< signed / unsigned number */
+#define __PRINTF_FLAG_SIGNED       0x00000002
+/** print leading zeroes */
-#define __PRINTF_FLAG_ZEROPADDED    0x00000004  /**< print leading zeroes */
+#define __PRINTF_FLAG_ZEROPADDED   0x00000004
+/** align to left */
-#define __PRINTF_FLAG_LEFTALIGNED   0x00000010  /**< align to left */
+#define __PRINTF_FLAG_LEFTALIGNED  0x00000010
+/** always show + sign */
-#define __PRINTF_FLAG_SHOWPLUS      0x00000020  /**< always show + sign */
+#define __PRINTF_FLAG_SHOWPLUS     0x00000020
+/** print space instead of plus */
-#define __PRINTF_FLAG_SPACESIGN     0x00000040  /**< print space instead of plus */
+#define __PRINTF_FLAG_SPACESIGN    0x00000040
+/** show big characters */
-#define __PRINTF_FLAG_BIGCHARS      0x00000080  /**< show big characters */
+#define __PRINTF_FLAG_BIGCHARS     0x00000080
+/** number has - sign */
-#define __PRINTF_FLAG_NEGATIVE      0x00000100  /**< number has - sign */
+#define __PRINTF_FLAG_NEGATIVE     0x00000100
-#define PRINT_NUMBER_BUFFER_SIZE    (64+5)      /**< Buffer big enought for 64 bit number
+/**
-                             * printed in base 2, sign, prefix and
+ * Buffer big enough for 64-bit number printed in base 2, sign, prefix and 0
-                             * 0 to terminate string.. (last one is only for better testing
+ * to terminate string... (last one is only for better testing end of buffer by
-                             * end of buffer by zero-filling subroutine)
+ * zero-filling subroutine)
-                             */
+ */
+#define PRINT_NUMBER_BUFFER_SIZE  (64 + 5)
 /** Enumeration of possible arguments types.
  */
 typedef enum {
     PrintfQualifierByte = 0,
     PrintfQualifierShort,
     PrintfQualifierInt,
     PrintfQualifierLong,
     PrintfQualifierLongLong,
-    PrintfQualifierSizeT,
     PrintfQualifierPointer
 } qualifier_t;
+static char nullstr[] = "(NULL)";
-static char digits_small[] = "0123456789abcdef";    /**< Small hexadecimal characters */
+static char digits_small[] = "0123456789abcdef";
-static char digits_big[] = "0123456789ABCDEF";      /**< Big hexadecimal characters */
+static char digits_big[] = "0123456789ABCDEF";
+static char invalch = U_SPECIAL;
-/** Print count chars from buffer without adding newline
+/** Print one or more characters without adding newline.
+ *
+ * @param buf  Buffer holding characters with size of
- * @param buf Buffer with size at least count bytes - NULL pointer NOT allowed!
+ *             at least size bytes. NULL is not allowed!
- * @param count
+ * @param size Size of the buffer in bytes.
- * @param ps output method and its data
+ * @param ps   Output method and its data.
+ *
- * @return number of printed characters
+ * @return Number of characters printed.
+ *
  */
-static int printf_putnchars(const char * buf, size_t count,
+static int printf_putnchars(const char *buf, size_t size,
-    struct printf_spec *ps)
+    printf_spec_t *ps)
+{
-    return ps->write((void *)buf, count, ps->data);
+    return ps->str_write((void *) buf, size, ps->data);
+}
-/** Print string without added newline
+/** Print one or more wide characters without adding newline.
+ *
+ * @param buf  Buffer holding wide characters with size of
+ *             at least size bytes. NULL is not allowed!
- * @param str string to print
+ * @param size Size of the buffer in bytes.
- * @param ps write function specification and support data
+ * @param ps   Output method and its data.
+ *
- * @return number of printed characters
+ * @return Number of wide characters printed.
+ *
  */
-static int printf_putstr(const char * str, struct printf_spec *ps)
+static int printf_wputnchars(const wchar_t *buf, size_t size,
+    printf_spec_t *ps)
+{
-    size_t count;
-    if (str == NULL)
-        return printf_putnchars("(NULL)", 6, ps);
+    return ps->wstr_write((void *) buf, size, ps->data);
+}
-    count = strlen(str);
+/** Print 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, printf_spec_t *ps)
+{
+    if (str == NULL)
+        return printf_putnchars(nullstr, str_size(nullstr), ps);
-    return ps->write((void *) str, count, ps->data);
+    return ps->str_write((void *) str, str_size(str), ps->data);
+}
-/** Print one character to output
+/** Print one ASCII character.
+ *
- * @param c one character
+ * @param c  ASCII character to be printed.
- * @param ps output method
+ * @param ps Output method.
+ *
- * @return number of printed characters
+ * @return Number of characters printed.
+ *
  */
-static int printf_putchar(int c, struct printf_spec *ps)
+static int printf_putchar(const char ch, printf_spec_t *ps)
+{
-    unsigned char ch = c;
+    if (!ascii_check(ch))
+        return ps->str_write((void *) &invalch, 1, ps->data);
-    return ps->write((void *) &ch, 1, ps->data);
+    return ps->str_write(&ch, 1, ps->data);
+}
-/** Print one formatted character
+/** Print one wide character.
+ *
- * @param c character to print
+ * @param c  Wide character to be printed.
- * @param width
+ * @param ps Output method.
- * @param flags
+ *
- * @return number of printed characters
+ * @return Number of characters printed.
+ *
  */
-static int print_char(char c, int width, uint64_t flags, struct printf_spec *ps)
+static int printf_putwchar(const wchar_t ch, printf_spec_t *ps)
+{
-    int counter = 0;
+    if (!chr_check(ch))
+        return ps->str_write((void *) &invalch, 1, ps->data);
+    return ps->wstr_write(&ch, sizeof(wchar_t), 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)) {
-        /*
-         * One space is consumed by the character itself, hence the
-         * predecrement.
-         */
         while (--width > 0) {
+            /*
+             * One space is consumed by the character itself, hence
+             * the predecrement.
+             */
             if (printf_putchar(' ', ps) > 0)
-                ++counter;
+                counter++;
+        }
+    }
-    if (printf_putchar(c, ps) > 0)
+    if (printf_putchar(ch, ps) > 0)
         counter++;
-    /*
-     * One space is consumed by the character itself, hence the
-     * predecrement.
-     */
     while (--width > 0) {
+        /*
+         * One space is consumed by the character itself, hence
+         * the predecrement.
+         */
         if (printf_putchar(' ', ps) > 0)
-            ++counter;
+            counter++;
+    }
-    return ++counter;
+    return (int) (counter + 1);
+}
-/** Print one string
+/** Print one formatted wide character.
+ *
- * @param s string
+ * @param ch    Character to print.
- * @param width
+ * @param width Width modifier.
- * @param precision
+ * @param flags Flags that change the way the character is printed.
- * @param flags
+ *
- * @return number of printed characters
+ * @return Number of characters printed, negative value on failure.
+ *
  */
-static int print_string(char *s, int width, int precision, uint64_t flags,
+static int print_wchar(const wchar_t ch, int width, uint32_t flags, printf_spec_t *ps)
-    struct printf_spec *ps)
+{
-    int counter = 0;
+    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)
-    size_t size;
+                counter++;
+        }
+    }
+    if (printf_putwchar(ch, ps) > 0)
-    int retval;
+        counter++;
-    if (s == NULL) {
+    while (--width > 0) {
+        /*
+         * One space is consumed by the character itself, hence
+         * the predecrement.
+         */
-        return printf_putstr("(NULL)", ps);
+        if (printf_putchar(' ', ps) > 0)
+            counter++;
+    }
-    size = strlen(s);
+    return (int) (counter + 1);
+}
-    /* print leading spaces */
+/** Print string.
+ *
+ * @param str       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_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. */
+    count_t strw = str_length(str);
     if (precision == 0)
-        precision = size;
+        precision = strw;
+    /* Left padding */
+    count_t counter = 0;
     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,
+    /* Part of @a str fitting into the alloted space. */
-        ps)) < 0) {
+    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;
+            counter++;
+    }
-    return counter;
+    return ((int) counter);
+}
+/** Print wide string.
+ *
+ * @param str       Wide 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 wide characters printed, negative value on failure.
+ */
+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);
+    if (*str == U_BOM)
+        str++;
+    /* Print leading spaces. */
+    size_t strw = wstr_length(str);
+    if (precision == 0)
+        precision = strw;
+    /* Left padding */
+    count_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);
+}
-/** Print number in given base
+/** Print a number in a given base.
+ *
+ * Print significant digits of a number in given base.
+ *
- * Print significant digits of a number in given
+ * @param num       Number to print.
- * base.
+ * @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.
+ *
- * @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
+ * @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)
+    uint32_t flags, printf_spec_t *ps)
+{
-    char *digits = digits_small;
+    char *digits;
-    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];
+    if (flags & __PRINTF_FLAG_BIGCHARS)
-    int size = 0; /* size of number with all prefixes and signs */
-    int number_size; /* size of plain number */
+        digits = digits_big;
-    char sgn;
+    else
-    int retval;
-    int counter = 0;
+        digits = digits_small;
-    if (flags & __PRINTF_FLAG_BIGCHARS)
+    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;
-        digits = digits_big;
+    /* Put zero at end of string */
+    *ptr-- = 0;
-    *ptr-- = 0; /* Put zero at end of string */
     if (num == 0) {
         *ptr-- = '0';
         size++;
     } else {
         do {
             *ptr-- = digits[num % base];
             size++;
         } while (num /= base);
+    }
+    /* Size of plain number */
-    number_size = size;
+    int number_size = size;
     /*
-     * Collect sum of all prefixes/signs/... to calculate padding and
+     * Collect the sum of all prefixes/signs/etc. to calculate padding and
-     * leading zeroes
+     * leading zeroes.
      */
     if (flags & __PRINTF_FLAG_PREFIX) {
         switch(base) {
+        case 2:
-        case 2: /* Binary formating is not standard, but usefull */
+            /* Binary formating is not standard, but usefull */
             size += 2;
             break;
         case 8:
             size++;
             break;
         case 16:
             size += 2;
             break;
+        }
+    }
-    sgn = 0;
+    char sgn = 0;
     if (flags & __PRINTF_FLAG_SIGNED) {
         if (flags & __PRINTF_FLAG_NEGATIVE) {
             sgn = '-';
             size++;
         } else if (flags & __PRINTF_FLAG_SHOWPLUS) {
         } else if (flags & __PRINTF_FLAG_SPACESIGN) {
             sgn = ' ';
             size++;
+        }
+    }
-    if (flags & __PRINTF_FLAG_LEFTALIGNED) {
+    if (flags & __PRINTF_FLAG_LEFTALIGNED)
         flags &= ~__PRINTF_FLAG_ZEROPADDED;
-    }
     /*
-     * If number is leftaligned or precision is specified then zeropadding
+     * If the number is left-aligned or precision is specified then
-     * is ignored.
+     * 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 */
-    /* We must print whole number not only a part. */
-    if (number_size > precision)
+    if (number_size > precision) {
+        /* Print the whole number, not only a part */
         precision = number_size;
+    }
     width -= precision + size - number_size;
+    count_t counter = 0;
     if (!(flags & __PRINTF_FLAG_LEFTALIGNED)) {
         while (width-- > 0) {
             if (printf_putchar(' ', ps) == 1)
                 counter++;
+        }
+    }
-    /* print sign */
+    /* Print sign */
     if (sgn) {
         if (printf_putchar(sgn, ps) == 1)
             counter++;
+    }
-    /* print prefix */
+    /* Print prefix */
     if (flags & __PRINTF_FLAG_PREFIX) {
         switch(base) {
+        case 2:
-        case 2: /* Binary formating is not standard, but usefull */
+            /* 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++;
                     counter++;
+            }
             break;
+        }
+    }
-    /* print leading zeroes */
+    /* Print leading zeroes */
     precision -= number_size;
     while (precision-- > 0) {
         if (printf_putchar('0', ps) == 1)
             counter++;
+    }
-    /* print number itself */
+    /* Print the number itself */
+    int retval;
-    if ((retval = printf_putstr(++ptr, ps)) > 0) {
+    if ((retval = printf_putstr(++ptr, ps)) > 0)
         counter += retval;
-    }
-    /* print ending spaces */
+    /* 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:@n
- *  - "#" Force to print prefix.
+ *  - "#" Force to print prefix. For \%o conversion, the prefix is 0, for
- *  For conversion \%o the prefix is 0, for %x and \%X prefixes are 0x and
+ *        \%x and \%X prefixes are 0x and 0X and for conversion \%b the
- *  0X and for conversion \%b the prefix is 0b.
+ *        prefix is 0b.
+ *
+ *  - "-" Align to left.
+ *
- *  - "-"   Align to left.
+ *  - "+" Print positive sign just as negative.
+ *
+ *  - " " If the printed number is positive and "+" flag is not set,
- *  - "+"   Print positive sign just as negative.
+ *        print space in place of sign.
+ *
- *  - " "   If the printed number is positive and "+" flag is not set,
+ *  - "0" Print 0 as padding instead of spaces. Zeroes are placed between
+ *        sign and the rest of the number. This flag is ignored if "-"
- *      print space in place of sign.
+ *        flag is specified.
+ *
- *  - "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
+ *  - Specify the minimal width of a printed argument. If it is bigger,
- *    ignored. If width is specified with a "*" character instead of number,
+ *    width is ignored. If width is specified with a "*" character instead of
- *    width is taken from parameter list. And integer parameter is expected
+ *    number, width is taken from parameter list. And integer parameter is
- *    before parameter for processed conversion specification. If this value
+ *    expected before parameter for processed conversion specification. If
- *    is negative its absolute value is taken and the "-" flag is set.
+ *    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
+ *    Smaller numbers are printed with leading zeroes. Bigger numbers are not
- *    not affected. Strings with more than precision characters are cut off.
+ *    affected. Strings with more than precision characters are cut off. Just
- *    Just as with width, an "*" can be used used instead of a number. An
+ *    as with width, an "*" can be used used instead of a number. An integer
- *    integer value is then expected in parameters. When both width and
+ *    value is then expected in parameters. When both width and precision are
- *    precision are specified using "*", the first parameter is used for
+ *    specified using "*", the first parameter is used for width and the
- *    width and the second one for precision.
+ *    second one for precision.
  *
  * TYPE:@n
- *  - "hh"  Signed or unsigned char.@n
+ *  - "hh" Signed or unsigned char.@n
- *  - "h"   Signed or usigned short.@n
+ *  - "h"  Signed or unsigned short.@n
- *  - ""    Signed or usigned int (default value).@n
+ *  - ""   Signed or unsigned int (default value).@n
- *  - "l"   Signed or usigned long int.@n
+ *  - "l"  Signed or unsigned long int.@n
+ *         If conversion is "c", the character is wchar_t (wide character).@n
+ *         If conversion is "s", the string is wchar_t * (wide string).@n
- *  - "ll"  Signed or usigned long long int.@n
+ *  - "ll" Signed or unsigned long long int.@n
- *  - "z"   Type size_t.@n
- *
  *
  * CONVERSION:@n
  *  - % Print percentile character itself.
+ *
+ *  - c Print single character. The character is expected to be plain
+ *      ASCII (e.g. only values 0 .. 127 are valid).@n
+ *      If type is "l", then the character is expected to be wide character
+ *      (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
+ *      If type is "l", then the string is expected to be wide string.
+ *
+ *  - 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
- *  - c Print single character.
+ *         not printed by default.
+ *
- *  - 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
+ * All other characters from fmt except the formatting directives are printed
  * verbatim.
+ *
- * @param fmt Formatting NULL terminated string.
+ * @param fmt Format NULL-terminated string.
+ *
- * @return Number of printed characters or negative value on failure.
+ * @return Number of characters printed, negative value on failure.
+ *
  */
-int printf_core(const char *fmt, struct printf_spec *ps, va_list ap)
+int printf_core(const char *fmt, printf_spec_t *ps, va_list ap)
+{
-    /* i is the index of the currently processed char from fmt */
+    size_t i;        /* Index of the currently processed character from fmt */
-    int i = 0;
+    size_t nxt = 0;  /* Index of the next character from fmt */
-    /* j is the index to the first not printed nonformating character */
+    size_t j = 0;    /* Index to the first not printed nonformating character */
-    int j = 0;
-    int end;
-    int counter;    /* counter of printed characters */
+    count_t counter = 0;  /* Number of characters printed */
-    int retval; /* used to store return values from called functions */
+    int retval;           /* Return values from nested functions */
-    char c;
-    qualifier_t qualifier;  /* type of argument */
+    while (true) {
-    int base;   /* base in which will be a numeric parameter printed */
-    uint64_t number; /* argument value */
+        i = nxt;
-    size_t  size;   /* byte size of integer parameter */
+        wchar_t uc = str_decode(fmt, &nxt, STR_NO_LIMIT);
-    int width, precision;
-    uint64_t flags;
-    counter = 0;
+        if (uc == 0)
+            break;
-    while ((c = fmt[i])) {
-        /* control character */
+        /* Control character */
-        if (c == '%' ) {
+        if (uc == '%') {
-            /* print common characters if any processed */
+            /* Print common characters if any processed */
             if (i > j) {
-                if ((retval = printf_putnchars(&fmt[j],
+                if ((retval = printf_putnchars(&fmt[j], i - j, ps)) < 0) {
-                    (size_t)(i - j), ps)) < 0) { /* error */
+                    /* Error */
+                    counter = -counter;
-                    goto minus_out;
+                    goto out;
+                }
                 counter += retval;
+            }
             j = i;
-            /* parse modifiers */
+            /* Parse modifiers */
-            flags = 0;
+            uint32_t flags = 0;
-            end = 0;
+            bool end = false;
             do {
-                ++i;
+                i = nxt;
+                uc = str_decode(fmt, &nxt, STR_NO_LIMIT);
-                switch (c = fmt[i]) {
+                switch (uc) {
                 case '#':
                     flags |= __PRINTF_FLAG_PREFIX;
                     break;
                 case '-':
                     flags |= __PRINTF_FLAG_LEFTALIGNED;
                     break;
                 case '0':
                     flags |= __PRINTF_FLAG_ZEROPADDED;
                     break;
                 default:
-                    end = 1;
+                    end = true;
                 };
-            } while (end == 0);
+            } while (!end);
-            /* width & '*' operator */
+            /* Width & '*' operator */
-            width = 0;
+            int width = 0;
-            if (isdigit(fmt[i])) {
+            if (isdigit(uc)) {
-                while (isdigit(fmt[i])) {
+                while (true) {
                     width *= 10;
-                    width += fmt[i++] - '0';
+                    width += uc - '0';
+                    i = nxt;
+                    uc = str_decode(fmt, &nxt, STR_NO_LIMIT);
+                    if (uc == 0)
+                        break;
+                    if (!isdigit(uc))
+                        break;
+                }
-            } else if (fmt[i] == '*') {
+            } else if (uc == '*') {
-                /* get width value from argument list*/
+                /* Get width value from argument list */
-                i++;
+                i = nxt;
+                uc = str_decode(fmt, &nxt, STR_NO_LIMIT);
-                width = (int)va_arg(ap, int);
+                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 and '*' operator */
-            precision = 0;
+            int precision = 0;
-            if (fmt[i] == '.') {
+            if (uc == '.') {
-                ++i;
+                i = nxt;
+                uc = str_decode(fmt, &nxt, STR_NO_LIMIT);
-                if (isdigit(fmt[i])) {
+                if (isdigit(uc)) {
-                    while (isdigit(fmt[i])) {
+                    while (true) {
                         precision *= 10;
-                        precision += fmt[i++] - '0';
+                        precision += uc - '0';
+                        i = nxt;
+                        uc = str_decode(fmt, &nxt, STR_NO_LIMIT);
+                        if (uc == 0)
+                            break;
+                        if (!isdigit(uc))
+                            break;
+                    }
-                } else if (fmt[i] == '*') {
+                } else if (uc == '*') {
-                    /* get precision value from argument */
+                    /* Get precision value from the argument list */
-                    i++;
+                    i = nxt;
+                    uc = str_decode(fmt, &nxt, STR_NO_LIMIT);
-                    precision = (int)va_arg(ap, int);
+                    precision = (int) va_arg(ap, int);
                     if (precision < 0) {
-                        /* negative precision ignored */
+                        /* Ignore negative precision */
                         precision = 0;
+                    }
+                }
+            }
+            qualifier_t qualifier;
-            switch (fmt[i++]) {
+            switch (uc) {
-            /** @todo unimplemented qualifiers:
+            /** @todo Unimplemented qualifiers:
-             * t ptrdiff_t - ISO C 99
+             *        t ptrdiff_t - ISO C 99
              */
+            case 'h':
-            case 'h':   /* char or short */
+                /* Char or short */
                 qualifier = PrintfQualifierShort;
+                i = nxt;
+                uc = str_decode(fmt, &nxt, STR_NO_LIMIT);
-                if (fmt[i] == 'h') {
+                if (uc == 'h') {
-                    i++;
+                    i = nxt;
+                    uc = str_decode(fmt, &nxt, STR_NO_LIMIT);
                     qualifier = PrintfQualifierByte;
+                }
                 break;
+            case 'l':
-            case 'l':   /* long or long long*/
+                /* Long or long long */
                 qualifier = PrintfQualifierLong;
+                i = nxt;
+                uc = str_decode(fmt, &nxt, STR_NO_LIMIT);
-                if (fmt[i] == 'l') {
+                if (uc == 'l') {
-                    i++;
+                    i = nxt;
+                    uc = str_decode(fmt, &nxt, STR_NO_LIMIT);
                     qualifier = PrintfQualifierLongLong;
+                }
                 break;
-            case 'z':   /* size_t */
-                qualifier = PrintfQualifierSizeT;
-                break;
             default:
-                /* set default type */
+                /* Default type */
                 qualifier = PrintfQualifierInt;
-                --i;
             }
-            base = 10;
+            unsigned int base = 10;
-            switch (c = fmt[i]) {
+            switch (uc) {
             /*
              * String and character conversions.
              */
             case 's':
+                if (qualifier == PrintfQualifierLong)
-                if ((retval = print_string(va_arg(ap, char*),
+                    retval = print_wstr(va_arg(ap, wchar_t *), width, precision, flags, ps);
+                else
-                    width, precision, flags, ps)) < 0) {
+                    retval = print_str(va_arg(ap, char *), width, precision, flags, ps);
+                if (retval < 0) {
+                    counter = -counter;
-                    goto minus_out;
+                    goto out;
+                }
                 counter += retval;
-                j = i + 1;
+                j = nxt;
                 goto next_char;
             case 'c':
-                c = va_arg(ap, unsigned int);
+                if (qualifier == PrintfQualifierLong)
-                retval = print_char(c, width, flags, ps);
+                    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 minus_out;
+                    goto out;
-                }
+                };
                 counter += retval;
-                j = i + 1;
+                j = nxt;
                 goto next_char;
             /*
              * Integer values
              */
+            case 'P':
-            case 'P': /* pointer */
+                /* Pointer */
-                    flags |= __PRINTF_FLAG_BIGCHARS;
+                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 */
+            /* Percentile itself */
             case '%':
                 j = i;
                 goto next_char;
             /*
              * Bad formatting.
              */
             default:
                 /*
-                 * Unknown format. Now, j is the index of '%',
+                 * Unknown format. Now, j is the index of '%'
-                 * so we will print the whole bad format
+                 * so we will print whole bad format sequence.
-                 * 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);
+                number = (uint64_t) va_arg(ap, unsigned int);
                 break;
             case PrintfQualifierShort:
                 size = sizeof(unsigned short);
-                number = (uint64_t)va_arg(ap, unsigned int);
+                number = (uint64_t) va_arg(ap, unsigned int);
                 break;
             case PrintfQualifierInt:
                 size = sizeof(unsigned int);
-                number = (uint64_t)va_arg(ap, 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);
+                number = (uint64_t) va_arg(ap, unsigned long);
                 break;
             case PrintfQualifierLongLong:
                 size = sizeof(unsigned long long);
-                number = (uint64_t)va_arg(ap,
+                number = (uint64_t) va_arg(ap, unsigned long long);
-                    unsigned long long);
                 break;
             case PrintfQualifierPointer:
                 size = sizeof(void *);
-                number = (uint64_t)(unsigned long)va_arg(ap,
+                number = (uint64_t) (unsigned long) va_arg(ap, void *);
-                    void *);
-                break;
-            case PrintfQualifierSizeT:
-                size = sizeof(size_t);
-                number = (uint64_t)va_arg(ap, size_t);
                 break;
+            default:
-            default: /* Unknown qualifier */
+                /* Unknown qualifier */
-                goto minus_out;
+                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);
+                        number = -((int64_t) number);
                     } else {
                         number = ~number;
                         number &=
                             ~(0xFFFFFFFFFFFFFFFFll <<
                             (size * 8));
                         number++;
+                    }
+                }
+            }
             if ((retval = print_number(number, width, precision,
-                base, flags, ps)) < 0 ) {
+                base, flags, ps)) < 0) {
+                counter = -counter;
-                goto minus_out;
+                goto out;
+            }
             counter += retval;
-            j = i + 1;
+            j = nxt;
         }
 next_char:
+        ;
-        ++i;
+    }
     if (i > j) {
-        retval = printf_putnchars(&fmt[j], (size_t)(i - j), ps);
+        if ((retval = printf_putnchars(&fmt[j], i - j, ps)) < 0) {
-        if (retval < 0) { /* error */
+            /* Error */
+            counter = -counter;
-            goto minus_out;
+            goto out;
+        }
         counter += retval;
+    }
-    return counter;
-minus_out:
+out:
-    return -counter;
+    return ((int) counter);
+}
 /** @}
  */

Subversion Repositories HelenOS

(root)//branches/network/uspace/lib/libc/generic/io/printf_core.c – Rev 3386 → 4263