Fork us on GitHub Follow us on Facebook Follow us on Twitter

Changeset 7fadb65 in mainline


Ignore:
Timestamp:
2011-08-23T17:44:33Z (10 years ago)
Author:
Martin Decky <martin@…>
Branches:
lfn, master
Children:
375ab5e, 4cf5ed46
Parents:
7ce7cfb
Message:

fix printout of signed integer arguments (thx Jiri Zarevucky)
synchronize printf implementations between boot, kernel and uspace

Files:
5 edited

Legend:

Unmodified
Added
Removed
  • boot/generic/src/printf_core.c

    r7ce7cfb r7fadb65  
    7070 */
    7171#define PRINT_NUMBER_BUFFER_SIZE  (64 + 5)
     72
     73/** Get signed or unsigned integer argument */
     74#define PRINTF_GET_INT_ARGUMENT(type, ap, flags) \
     75        ({ \
     76                unsigned type res; \
     77                \
     78                if ((flags) & __PRINTF_FLAG_SIGNED) { \
     79                        signed type arg = va_arg((ap), signed type); \
     80                        \
     81                        if (arg < 0) { \
     82                                res = -arg; \
     83                                (flags) |= __PRINTF_FLAG_NEGATIVE; \
     84                        } else \
     85                                res = arg; \
     86                } else \
     87                        res = va_arg((ap), unsigned type); \
     88                \
     89                res; \
     90        })
    7291
    7392/** Enumeration of possible arguments types.
     
    171190        }
    172191       
    173         return (int) (counter + 1);
     192        return (int) (counter);
    174193}
    175194
     
    698717                        size_t size;
    699718                        uint64_t number;
     719                       
    700720                        switch (qualifier) {
    701721                        case PrintfQualifierByte:
    702722                                size = sizeof(unsigned char);
    703                                 number = (uint64_t) va_arg(ap, unsigned int);
     723                                number = PRINTF_GET_INT_ARGUMENT(int, ap, flags);
    704724                                break;
    705725                        case PrintfQualifierShort:
    706726                                size = sizeof(unsigned short);
    707                                 number = (uint64_t) va_arg(ap, unsigned int);
     727                                number = PRINTF_GET_INT_ARGUMENT(int, ap, flags);
    708728                                break;
    709729                        case PrintfQualifierInt:
    710730                                size = sizeof(unsigned int);
    711                                 number = (uint64_t) va_arg(ap, unsigned int);
     731                                number = PRINTF_GET_INT_ARGUMENT(int, ap, flags);
    712732                                break;
    713733                        case PrintfQualifierLong:
    714734                                size = sizeof(unsigned long);
    715                                 number = (uint64_t) va_arg(ap, unsigned long);
     735                                number = PRINTF_GET_INT_ARGUMENT(long, ap, flags);
    716736                                break;
    717737                        case PrintfQualifierLongLong:
    718738                                size = sizeof(unsigned long long);
    719                                 number = (uint64_t) va_arg(ap, unsigned long long);
     739                                number = PRINTF_GET_INT_ARGUMENT(long long, ap, flags);
    720740                                break;
    721741                        case PrintfQualifierPointer:
     
    732752                                counter = -counter;
    733753                                goto out;
    734                         }
    735                        
    736                         if (flags & __PRINTF_FLAG_SIGNED) {
    737                                 if (number & (0x1 << (size * 8 - 1))) {
    738                                         flags |= __PRINTF_FLAG_NEGATIVE;
    739                                        
    740                                         if (size == sizeof(uint64_t)) {
    741                                                 number = -((int64_t) number);
    742                                         } else {
    743                                                 number = ~number;
    744                                                 number &=
    745                                                     ~(0xFFFFFFFFFFFFFFFFll <<
    746                                                     (size * 8));
    747                                                 number++;
    748                                         }
    749                                 }
    750754                        }
    751755                       
  • kernel/generic/src/printf/printf_core.c

    r7ce7cfb r7fadb65  
    7575#define PRINT_NUMBER_BUFFER_SIZE  (64 + 5)
    7676
     77/** Get signed or unsigned integer argument */
     78#define PRINTF_GET_INT_ARGUMENT(type, ap, flags) \
     79        ({ \
     80                unsigned type res; \
     81                \
     82                if ((flags) & __PRINTF_FLAG_SIGNED) { \
     83                        signed type arg = va_arg((ap), signed type); \
     84                        \
     85                        if (arg < 0) { \
     86                                res = -arg; \
     87                                (flags) |= __PRINTF_FLAG_NEGATIVE; \
     88                        } else \
     89                                res = arg; \
     90                } else \
     91                        res = va_arg((ap), unsigned type); \
     92                \
     93                res; \
     94        })
     95
    7796/** Enumeration of possible arguments types.
    7897 */
     
    207226        }
    208227       
    209         return (int) (counter + 1);
     228        return (int) (counter);
    210229}
    211230
     
    245264        }
    246265       
    247         return (int) (counter + 1);
     266        return (int) (counter);
    248267}
    249268
     
    832851                        size_t size;
    833852                        uint64_t number;
     853                       
    834854                        switch (qualifier) {
    835855                        case PrintfQualifierByte:
    836856                                size = sizeof(unsigned char);
    837                                 number = (uint64_t) va_arg(ap, unsigned int);
     857                                number = PRINTF_GET_INT_ARGUMENT(int, ap, flags);
    838858                                break;
    839859                        case PrintfQualifierShort:
    840860                                size = sizeof(unsigned short);
    841                                 number = (uint64_t) va_arg(ap, unsigned int);
     861                                number = PRINTF_GET_INT_ARGUMENT(int, ap, flags);
    842862                                break;
    843863                        case PrintfQualifierInt:
    844864                                size = sizeof(unsigned int);
    845                                 number = (uint64_t) va_arg(ap, unsigned int);
     865                                number = PRINTF_GET_INT_ARGUMENT(int, ap, flags);
    846866                                break;
    847867                        case PrintfQualifierLong:
    848868                                size = sizeof(unsigned long);
    849                                 number = (uint64_t) va_arg(ap, unsigned long);
     869                                number = PRINTF_GET_INT_ARGUMENT(long, ap, flags);
    850870                                break;
    851871                        case PrintfQualifierLongLong:
    852872                                size = sizeof(unsigned long long);
    853                                 number = (uint64_t) va_arg(ap, unsigned long long);
     873                                number = PRINTF_GET_INT_ARGUMENT(long long, ap, flags);
    854874                                break;
    855875                        case PrintfQualifierPointer:
     
    866886                                counter = -counter;
    867887                                goto out;
    868                         }
    869                        
    870                         if (flags & __PRINTF_FLAG_SIGNED) {
    871                                 if (number & (0x1 << (size * 8 - 1))) {
    872                                         flags |= __PRINTF_FLAG_NEGATIVE;
    873                                        
    874                                         if (size == sizeof(uint64_t)) {
    875                                                 number = -((int64_t) number);
    876                                         } else {
    877                                                 number = ~number;
    878                                                 number &=
    879                                                     ~(0xFFFFFFFFFFFFFFFFll <<
    880                                                     (size * 8));
    881                                                 number++;
    882                                         }
    883                                 }
    884888                        }
    885889                       
  • kernel/test/print/print2.c

    r7ce7cfb r7fadb65  
    4444        TPRINTF("Real output:     [%d] [%3.2d] [%-3.2d] [%2.3d] [%-2.3d]\n\n", -1, -2, -3, -4, -5);
    4545       
     46        TPRINTF("Testing printf(\"%%lld %%3.2lld %%-3.2lld %%2.3lld %%-2.3lld\", (long long) -1, (long long) -2, (long long) -3, (long long) -4, (long long) -5):\n");
     47        TPRINTF("Expected output: [-1] [-02] [-03] [-004] [-005]\n");
     48        TPRINTF("Real output:     [%lld] [%3.2lld] [%-3.2lld] [%2.3lld] [%-2.3lld]\n\n", (long long) -1, (long long) -2, (long long) -3, (long long) -4, (long long) -5);
     49       
    4650        TPRINTF("Testing printf(\"%%#x %%5.3#x %%-5.3#x %%3.5#x %%-3.5#x\", 17, 18, 19, 20, 21):\n");
    4751        TPRINTF("Expected output: [0x11] [0x012] [0x013] [0x00014] [0x00015]\n");
  • uspace/app/tester/print/print2.c

    r7ce7cfb r7fadb65  
    4545        TPRINTF("Real output:     [%d] [%3.2d] [%-3.2d] [%2.3d] [%-2.3d]\n\n", -1, -2, -3, -4, -5);
    4646       
     47        TPRINTF("Testing printf(\"%%lld %%3.2lld %%-3.2lld %%2.3lld %%-2.3lld\", (long long) -1, (long long) -2, (long long) -3, (long long) -4, (long long) -5):\n");
     48        TPRINTF("Expected output: [-1] [-02] [-03] [-004] [-005]\n");
     49        TPRINTF("Real output:     [%lld] [%3.2lld] [%-3.2lld] [%2.3lld] [%-2.3lld]\n\n", (long long) -1, (long long) -2, (long long) -3, (long long) -4, (long long) -5);
     50       
    4751        TPRINTF("Testing printf(\"%%#x %%5.3#x %%-5.3#x %%3.5#x %%-3.5#x\", 17, 18, 19, 20, 21):\n");
    4852        TPRINTF("Expected output: [0x11] [0x012] [0x013] [0x00014] [0x00015]\n");
  • uspace/lib/c/generic/io/printf_core.c

    r7ce7cfb r7fadb65  
    7373 */
    7474#define PRINT_NUMBER_BUFFER_SIZE  (64 + 5)
     75
     76/** Get signed or unsigned integer argument */
     77#define PRINTF_GET_INT_ARGUMENT(type, ap, flags) \
     78        ({ \
     79                unsigned type res; \
     80                \
     81                if ((flags) & __PRINTF_FLAG_SIGNED) { \
     82                        signed type arg = va_arg((ap), signed type); \
     83                        \
     84                        if (arg < 0) { \
     85                                res = -arg; \
     86                                (flags) |= __PRINTF_FLAG_NEGATIVE; \
     87                        } else \
     88                                res = arg; \
     89                } else \
     90                        res = va_arg((ap), unsigned type); \
     91                \
     92                res; \
     93        })
    7594
    7695/** Enumeration of possible arguments types.
     
    831850                        size_t size;
    832851                        uint64_t number;
     852                       
    833853                        switch (qualifier) {
    834854                        case PrintfQualifierByte:
    835855                                size = sizeof(unsigned char);
    836                                 number = (uint64_t) va_arg(ap, unsigned int);
     856                                number = PRINTF_GET_INT_ARGUMENT(int, ap, flags);
    837857                                break;
    838858                        case PrintfQualifierShort:
    839859                                size = sizeof(unsigned short);
    840                                 number = (uint64_t) va_arg(ap, unsigned int);
     860                                number = PRINTF_GET_INT_ARGUMENT(int, ap, flags);
    841861                                break;
    842862                        case PrintfQualifierInt:
    843863                                size = sizeof(unsigned int);
    844                                 number = (uint64_t) va_arg(ap, unsigned int);
     864                                number = PRINTF_GET_INT_ARGUMENT(int, ap, flags);
    845865                                break;
    846866                        case PrintfQualifierLong:
    847867                                size = sizeof(unsigned long);
    848                                 number = (uint64_t) va_arg(ap, unsigned long);
     868                                number = PRINTF_GET_INT_ARGUMENT(long, ap, flags);
    849869                                break;
    850870                        case PrintfQualifierLongLong:
    851871                                size = sizeof(unsigned long long);
    852                                 number = (uint64_t) va_arg(ap, unsigned long long);
     872                                number = PRINTF_GET_INT_ARGUMENT(long long, ap, flags);
    853873                                break;
    854874                        case PrintfQualifierPointer:
     
    865885                                counter = -counter;
    866886                                goto out;
    867                         }
    868                        
    869                         if (flags & __PRINTF_FLAG_SIGNED) {
    870                                 if (number & (0x1 << (size * 8 - 1))) {
    871                                         flags |= __PRINTF_FLAG_NEGATIVE;
    872                                        
    873                                         if (size == sizeof(uint64_t)) {
    874                                                 number = -((int64_t) number);
    875                                         } else {
    876                                                 number = ~number;
    877                                                 number &=
    878                                                     ~(0xFFFFFFFFFFFFFFFFll <<
    879                                                     (size * 8));
    880                                                 number++;
    881                                         }
    882                                 }
    883887                        }
    884888                       
Note: See TracChangeset for help on using the changeset viewer.