Ignore:
Timestamp:
2009-04-03T07:54:27Z (16 years ago)
Author:
Martin Decky <martin@…>
Branches:
lfn, master, serial, ticket/834-toolchain-update, topic/msim-upgrade, topic/simplify-dev-export
Children:
d1dabe1f
Parents:
b888d5f
Message:

cleanup, string changes

File:
1 edited

Legend:

Unmodified
Added
Removed

  • kernel/generic/src/printf/printf_core.c

    rb888d5f r043eca0  
    8383static char digits_big[] = "0123456789ABCDEF";
    8484
    85 /** Print one or more UTF-8 characters without adding newline.
    86  *
    87  * @param buf  Buffer holding UTF-8 characters with size of
     85/** Print one or more characters without adding newline.
     86 *
     87 * @param buf  Buffer holding characters with size of
    8888 *             at least size bytes. NULL is not allowed!
    8989 * @param size Size of the buffer in bytes.
    9090 * @param ps   Output method and its data.
    9191 *
    92  * @return Number of UTF-8 characters printed.
    93  *
    94  */
    95 static int printf_putnchars_utf8(const char *buf, size_t size,
     92 * @return Number of characters printed.
     93 *
     94 */
     95static int printf_putnchars(const char *buf, size_t size,
    9696    printf_spec_t *ps)
    9797{
    98         return ps->write_utf8((void *) buf, size, ps->data);
    99 }
    100 
    101 /** Print one or more UTF-32 characters without adding newline.
    102  *
    103  * @param buf  Buffer holding UTF-32 characters with size of
     98        return ps->str_write((void *) buf, size, ps->data);
     99}
     100
     101/** Print one or more wide characters without adding newline.
     102 *
     103 * @param buf  Buffer holding wide characters with size of
    104104 *             at least size bytes. NULL is not allowed!
    105105 * @param size Size of the buffer in bytes.
    106106 * @param ps   Output method and its data.
    107107 *
    108  * @return Number of UTF-32 characters printed.
    109  *
    110  */
    111 static int printf_putnchars_utf32(const wchar_t *buf, size_t size,
     108 * @return Number of wide characters printed.
     109 *
     110 */
     111static int printf_wputnchars(const wchar_t *buf, size_t size,
    112112    printf_spec_t *ps)
    113113{
    114         return ps->write_utf32((void *) buf, size, ps->data);
    115 }
    116 
    117 /** Print string without adding newline.
    118  *
    119  * @param str   String to print.
    120  * @param ps    Write function specification and support data.
     114        return ps->wstr_write((void *) buf, size, ps->data);
     115}
     116
     117/** Print string without adding a newline.
     118 *
     119 * @param str String to print.
     120 * @param ps  Write function specification and support data.
    121121 *
    122122 * @return Number of characters printed.
    … …  
    126126{
    127127        if (str == NULL)
    128                 return printf_putnchars_utf8(nullstr, str_size(nullstr), ps);
    129        
    130         return ps->write_utf8((void *) str, str_size(str), ps->data);
     128                return printf_putnchars(nullstr, str_size(nullstr), ps);
     129       
     130        return ps->str_write((void *) str, str_size(str), ps->data);
    131131}
    132132
    … …  
    142142{
    143143        if (!ascii_check(ch))
    144                 return ps->write_utf8((void *) &invalch, 1, ps->data);
    145        
    146         return ps->write_utf8(&ch, 1, ps->data);
    147 }
    148 
    149 /** Print one UTF-32 character.
    150  *
    151  * @param c  UTF-32 character to be printed.
     144                return ps->str_write((void *) &invalch, 1, ps->data);
     145       
     146        return ps->str_write(&ch, 1, ps->data);
     147}
     148
     149/** Print one wide character.
     150 *
     151 * @param c  Wide character to be printed.
    152152 * @param ps Output method.
    153153 *
    … …  
    157157static int printf_putwchar(const wchar_t ch, printf_spec_t *ps)
    158158{
    159         if (!unicode_check(ch))
    160                 return ps->write_utf8((void *) &invalch, 1, ps->data);
    161        
    162         return ps->write_utf32(&ch, sizeof(wchar_t), ps->data);
     159        if (!chr_check(ch))
     160                return ps->str_write((void *) &invalch, 1, ps->data);
     161       
     162        return ps->wstr_write(&ch, sizeof(wchar_t), ps->data);
    163163}
    164164
    … …  
    201201}
    202202
    203 /** Print one formatted UTF-32 character.
     203/** Print one formatted wide character.
    204204 *
    205205 * @param ch    Character to print.
    … …  
    239239}
    240240
    241 /** Format and print a string.
     241/** Print string.
    242242 *
    243243 * @param str       String to be printed.
    … …  
    271271        /* Part of @a str fitting into the alloted space. */
    272272        int retval;
    273         size_t size = str_wsize(str, precision);
    274         if ((retval = printf_putnchars_utf8(str, size, ps)) < 0)
     273        size_t size = str_lsize(str, precision);
     274        if ((retval = printf_putnchars(str, size, ps)) < 0)
    275275                return -counter;
    276276
    … …  
    287287}
    288288
    289 /** Format and print a wide string.
    290  *
    291  * @param wstr          Wide string to be printed.
    292  * @param width         Width modifier.
    293  * @param precision     Precision modifier.
    294  * @param flags         Flags that modify the way the string is printed.
    295  *
    296  * @return              Number of characters printed, negative value
    297  *                      on failure.
    298  */
    299 static int print_wstr(wchar_t *wstr, int width, unsigned int precision,
     289/** Print wide string.
     290 *
     291 * @param str       Wide string to be printed.
     292 * @param width     Width modifier.
     293 * @param precision Precision modifier.
     294 * @param flags     Flags that modify the way the string is printed.
     295 *
     296 * @return Number of wide characters printed, negative value on failure.
     297 */
     298static int print_wstr(wchar_t *str, int width, unsigned int precision,
    300299        uint32_t flags, printf_spec_t *ps)
    301300{
    302         if (wstr == NULL)
     301        if (str == NULL)
    303302                return printf_putstr(nullstr, ps);
    304303
    305304        /* Print leading spaces. */
    306         size_t strw = wstr_length(wstr);
     305        size_t strw = wstr_length(str);
    307306        if (precision == 0)
    308307                precision = strw;
    … …  
    320319        /* Part of @a wstr fitting into the alloted space. */
    321320        int retval;
    322         size_t size = wstr_wlength(wstr, precision) * sizeof(wchar_t);
    323         if ((retval = printf_putnchars_utf32(wstr, size, ps)) < 0)
     321        size_t size = wstr_lsize(str, precision);
     322        if ((retval = printf_wputnchars(str, size, ps)) < 0)
    324323                return -counter;
    325324
    … …  
    424423        }
    425424       
    426         /* Print leading spaces. */
     425        /* Print leading spaces */
    427426        if (number_size > precision) {
    428                 /* Print the whole number, not only a part. */
     427                /* Print the whole number, not only a part */
    429428                precision = number_size;
    430429        }
    … …  
    440439        }
    441440       
    442         /* Print sign. */
     441        /* Print sign */
    443442        if (sgn) {
    444443                if (printf_putchar(sgn, ps) == 1)
    … …  
    446445        }
    447446       
    448         /* Print prefix. */
     447        /* Print prefix */
    449448        if (flags & __PRINTF_FLAG_PREFIX) {
    450449                switch(base) {
    … …  
    479478        }
    480479       
    481         /* Print leading zeroes. */
     480        /* Print leading zeroes */
    482481        precision -= number_size;
    483482        while (precision-- > 0) {
    … …  
    486485        }
    487486       
    488         /* Print the number itself. */
     487        /* Print the number itself */
    489488        int retval;
    490489        if ((retval = printf_putstr(++ptr, ps)) > 0)
    491490                counter += retval;
    492491       
    493         /* Print tailing spaces. */
     492        /* Print tailing spaces */
    494493       
    495494        while (width-- > 0) {
    … …  
    546545 *  - ""   Signed or unsigned int (default value).@n
    547546 *  - "l"  Signed or unsigned long int.@n
    548  *         If conversion is "c", the character is wchar_t (UTF-32).@n
    549  *         If conversion is "s", the string is wchar_t * (UTF-32).@n
     547 *         If conversion is "c", the character is wchar_t (wide character).@n
     548 *         If conversion is "s", the string is wchar_t * (wide string).@n
    550549 *  - "ll" Signed or unsigned long long int.@n
    551550 *
    … …  
    555554 *  - c Print single character. The character is expected to be plain
    556555 *      ASCII (e.g. only values 0 .. 127 are valid).@n
    557  *      If type is "l", then the character is expected to be UTF-32
     556 *      If type is "l", then the character is expected to be wide character
    558557 *      (e.g. values 0 .. 0x10ffff are valid).
    559558 *
    560559 *  - s Print zero terminated string. If a NULL value is passed as
    561560 *      value, "(NULL)" is printed instead.@n
    562  *      The string is expected to be correctly encoded UTF-8 (or plain
    563  *      ASCII, which is a subset of UTF-8).@n
    564  *      If type is "l", then the string is expected to be correctly
    565  *      encoded UTF-32.
     561 *      If type is "l", then the string is expected to be wide string.
    566562 *
    567563 *  - P, p Print value of a pointer. Void * value is expected and it is
    … …  
    586582 * verbatim.
    587583 *
    588  * @param fmt Format string.
     584 * @param fmt Format NULL-terminated string.
     585 *
    589586 * @return Number of characters printed, negative value on failure.
    590587 *
    … …  
    592589int printf_core(const char *fmt, printf_spec_t *ps, va_list ap)
    593590{
    594         size_t i = 0;  /* Index of the currently processed character from fmt */
    595         size_t nxt = 0;
    596         size_t j = 0;  /* Index to the first not printed nonformating character */
    597        
    598         wchar_t uc;           /* Current character decoded from fmt */
     591        size_t i;        /* Index of the currently processed character from fmt */
     592        size_t nxt = 0;  /* Index of the next character from fmt */
     593        size_t j = 0;    /* Index to the first not printed nonformating character */
     594       
    599595        count_t counter = 0;  /* Number of characters printed */
    600596        int retval;           /* Return values from nested functions */
    … …  
    602598        while (true) {
    603599                i = nxt;
    604                 uc = chr_decode(fmt, &nxt, UTF8_NO_LIMIT);
    605 
    606                 if (uc == '\0') break;
    607 
     600                wchar_t uc = str_decode(fmt, &nxt, STR_NO_LIMIT);
     601               
     602                if (uc == 0)
     603                        break;
     604               
    608605                /* Control character */
    609606                if (uc == '%') {
    610607                        /* Print common characters if any processed */
    611608                        if (i > j) {
    612                                 if ((retval = printf_putnchars_utf8(&fmt[j], i - j, ps)) < 0) {
     609                                if ((retval = printf_putnchars(&fmt[j], i - j, ps)) < 0) {
    613610                                        /* Error */
    614611                                        counter = -counter;
    … …  
    626623                        do {
    627624                                i = nxt;
    628                                 uc = chr_decode(fmt, &nxt, UTF8_NO_LIMIT);
     625                                uc = str_decode(fmt, &nxt, STR_NO_LIMIT);
    629626                                switch (uc) {
    630627                                case '#':
    … …  
    654651                                        width *= 10;
    655652                                        width += uc - '0';
    656 
     653                                       
    657654                                        i = nxt;
    658                                         uc = chr_decode(fmt, &nxt, UTF8_NO_LIMIT);
    659                                         if (uc == '\0')
     655                                        uc = str_decode(fmt, &nxt, STR_NO_LIMIT);
     656                                        if (uc == 0)
    660657                                                break;
    661658                                        if (!isdigit(uc))
    … …  
    665662                                /* Get width value from argument list */
    666663                                i = nxt;
    667                                 uc = chr_decode(fmt, &nxt, UTF8_NO_LIMIT);
     664                                uc = str_decode(fmt, &nxt, STR_NO_LIMIT);
    668665                                width = (int) va_arg(ap, int);
    669666                                if (width < 0) {
    … …  
    678675                        if (uc == '.') {
    679676                                i = nxt;
    680                                 uc = chr_decode(fmt, &nxt, UTF8_NO_LIMIT);
     677                                uc = str_decode(fmt, &nxt, STR_NO_LIMIT);
    681678                                if (isdigit(uc)) {
    682679                                        while (true) {
    683680                                                precision *= 10;
    684681                                                precision += uc - '0';
    685 
     682                                               
    686683                                                i = nxt;
    687                                                 uc = chr_decode(fmt, &nxt, UTF8_NO_LIMIT);
    688                                                 if (uc == '\0')
     684                                                uc = str_decode(fmt, &nxt, STR_NO_LIMIT);
     685                                                if (uc == 0)
    689686                                                        break;
    690687                                                if (!isdigit(uc))
    … …  
    694691                                        /* Get precision value from the argument list */
    695692                                        i = nxt;
    696                                         uc = chr_decode(fmt, &nxt, UTF8_NO_LIMIT);
     693                                        uc = str_decode(fmt, &nxt, STR_NO_LIMIT);
    697694                                        precision = (int) va_arg(ap, int);
    698695                                        if (precision < 0) {
    … …  
    713710                                qualifier = PrintfQualifierShort;
    714711                                i = nxt;
    715                                 uc = chr_decode(fmt, &nxt, UTF8_NO_LIMIT);
     712                                uc = str_decode(fmt, &nxt, STR_NO_LIMIT);
    716713                                if (uc == 'h') {
    717714                                        i = nxt;
    718                                         uc = chr_decode(fmt, &nxt, UTF8_NO_LIMIT);
     715                                        uc = str_decode(fmt, &nxt, STR_NO_LIMIT);
    719716                                        qualifier = PrintfQualifierByte;
    720717                                }
    … …  
    724721                                qualifier = PrintfQualifierLong;
    725722                                i = nxt;
    726                                 uc = chr_decode(fmt, &nxt, UTF8_NO_LIMIT);
     723                                uc = str_decode(fmt, &nxt, STR_NO_LIMIT);
    727724                                if (uc == 'l') {
    728725                                        i = nxt;
    729                                         uc = chr_decode(fmt, &nxt, UTF8_NO_LIMIT);
     726                                        uc = str_decode(fmt, &nxt, STR_NO_LIMIT);
    730727                                        qualifier = PrintfQualifierLongLong;
    731728                                }
    … …  
    879876       
    880877        if (i > j) {
    881                 if ((retval = printf_putnchars_utf8(&fmt[j], i - j, ps)) < 0) {
     878                if ((retval = printf_putnchars(&fmt[j], i - j, ps)) < 0) {
    882879                        /* Error */
    883880                        counter = -counter;
Note: See TracChangeset for help on using the changeset viewer.