Subversion Repositories HelenOS

Rev

Rev 2071 | Go to most recent revision | Blame | Compare with Previous | Last modification | View Log | Download | RSS feed

  1. /*
  2.  * Copyright (c) 2001-2004 Jakub Jermar
  3.  * Copyright (c) 2006 Josef Cejka
  4.  * All rights reserved.
  5.  *
  6.  * Redistribution and use in source and binary forms, with or without
  7.  * modification, are permitted provided that the following conditions
  8.  * are met:
  9.  *
  10.  * - Redistributions of source code must retain the above copyright
  11.  *   notice, this list of conditions and the following disclaimer.
  12.  * - Redistributions in binary form must reproduce the above copyright
  13.  *   notice, this list of conditions and the following disclaimer in the
  14.  *   documentation and/or other materials provided with the distribution.
  15.  * - The name of the author may not be used to endorse or promote products
  16.  *   derived from this software without specific prior written permission.
  17.  *
  18.  * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR
  19.  * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
  20.  * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
  21.  * IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT,
  22.  * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
  23.  * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
  24.  * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
  25.  * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
  26.  * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
  27.  * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
  28.  */
  29.  
  30. /** @addtogroup libc
  31.  * @{
  32.  */
  33. /**
  34.  * @file
  35.  * @brief   Printing functions.
  36.  */
  37.  
  38. #include <unistd.h>
  39. #include <stdio.h>
  40. #include <io/printf_core.h>
  41. #include <ctype.h>
  42. #include <string.h>
  43. /* For serialization */
  44. #include <async.h>
  45.  
  46. #define __PRINTF_FLAG_PREFIX        0x00000001  /**< show prefixes 0x or 0*/
  47. #define __PRINTF_FLAG_SIGNED        0x00000002  /**< signed / unsigned number */
  48. #define __PRINTF_FLAG_ZEROPADDED    0x00000004  /**< print leading zeroes */
  49. #define __PRINTF_FLAG_LEFTALIGNED   0x00000010  /**< align to left */
  50. #define __PRINTF_FLAG_SHOWPLUS      0x00000020  /**< always show + sign */
  51. #define __PRINTF_FLAG_SPACESIGN     0x00000040  /**< print space instead of plus */
  52. #define __PRINTF_FLAG_BIGCHARS      0x00000080  /**< show big characters */
  53. #define __PRINTF_FLAG_NEGATIVE      0x00000100  /**< number has - sign */
  54.  
  55. #define PRINT_NUMBER_BUFFER_SIZE    (64+5)      /**< Buffer big enought for 64 bit number
  56.                              * printed in base 2, sign, prefix and
  57.                              * 0 to terminate string.. (last one is only for better testing
  58.                              * end of buffer by zero-filling subroutine)
  59.                              */
  60. /** Enumeration of possible arguments types.
  61.  */
  62. typedef enum {
  63.     PrintfQualifierByte = 0,
  64.     PrintfQualifierShort,
  65.     PrintfQualifierInt,
  66.     PrintfQualifierLong,
  67.     PrintfQualifierLongLong,
  68.     PrintfQualifierSizeT,
  69.     PrintfQualifierPointer
  70. } qualifier_t;
  71.  
  72. static char digits_small[] = "0123456789abcdef";    /**< Small hexadecimal characters */
  73. static char digits_big[] = "0123456789ABCDEF";      /**< Big hexadecimal characters */
  74.  
  75. /** Print count chars from buffer without adding newline
  76.  * @param buf Buffer with size at least count bytes - NULL pointer NOT allowed!
  77.  * @param count
  78.  * @param ps output method and its data
  79.  * @return number of printed characters
  80.  */
  81. static int printf_putnchars(const char * buf, size_t count, struct printf_spec *ps)
  82. {
  83.     return ps->write((void *)buf, count, ps->data);
  84. }
  85.  
  86. /** Print string without added newline
  87.  * @param str string to print
  88.  * @param ps write function specification and support data
  89.  * @return number of printed characters
  90.  */
  91. static int printf_putstr(const char * str, struct printf_spec *ps)
  92. {
  93.     size_t count;
  94.    
  95.     if (str == NULL) {
  96.         return printf_putnchars("(NULL)", 6, ps);
  97.     }
  98.  
  99.     for (count = 0; str[count] != 0; count++);
  100.  
  101.     if (ps->write((void *) str, count, ps->data) == count) {
  102.         return 0;
  103.     }
  104.    
  105.     return EOF;
  106. }
  107.  
  108. /** Print one character to output
  109.  * @param c one character
  110.  * @param ps output method
  111.  * @return number of printed characters
  112.  */
  113. static int printf_putchar(int c, struct printf_spec *ps)
  114. {
  115.     unsigned char ch = c;
  116.    
  117.     return ps->write((void *) &ch, 1, ps->data);
  118. }
  119.  
  120. /** Print one formatted character
  121.  * @param c character to print
  122.  * @param width
  123.  * @param flags
  124.  * @return number of printed characters
  125.  */
  126. static int print_char(char c, int width, uint64_t flags, struct printf_spec *ps)
  127. {
  128.     int counter = 0;
  129.    
  130.     if (!(flags & __PRINTF_FLAG_LEFTALIGNED)) {
  131.         while (--width > 0) {   /* one space is consumed by character itself hence predecrement */
  132.             if (printf_putchar(' ', ps) > 0)   
  133.                 ++counter;
  134.         }
  135.     }
  136.    
  137.     if (printf_putchar(c, ps) > 0)
  138.         counter++;
  139.    
  140.     while (--width > 0) { /* one space is consumed by character itself hence predecrement */
  141.         if (printf_putchar(' ', ps) > 0)
  142.             ++counter;
  143.     }
  144.    
  145.     return ++counter;
  146. }
  147.  
  148. /** Print one string
  149.  * @param s string
  150.  * @param width
  151.  * @param precision
  152.  * @param flags
  153.  * @return number of printed characters
  154.  */
  155.                        
  156. static int print_string(char *s, int width, int precision, uint64_t flags, struct printf_spec *ps)
  157. {
  158.     int counter = 0;
  159.     size_t size;
  160.     int retval;
  161.  
  162.     if (s == NULL) {
  163.         return printf_putstr("(NULL)", ps);
  164.     }
  165.    
  166.     size = strlen(s);
  167.  
  168.     /* print leading spaces */
  169.  
  170.     if (precision == 0)
  171.         precision = size;
  172.  
  173.     width -= precision;
  174.    
  175.     if (!(flags & __PRINTF_FLAG_LEFTALIGNED)) {
  176.         while (width-- > 0) {  
  177.             if (printf_putchar(' ', ps) == 1)  
  178.                 counter++;
  179.         }
  180.     }
  181.  
  182.     while (precision > size) {
  183.         precision--;
  184.         if (printf_putchar(' ', ps) == 1)  
  185.             ++counter;
  186.     }
  187.    
  188.     if ((retval = printf_putnchars(s, precision, ps)) < 0) {
  189.         return -counter;
  190.     }
  191.  
  192.     counter += retval; 
  193.  
  194.     while (width-- > 0) {
  195.         if (printf_putchar(' ', ps) == 1)  
  196.             ++counter;
  197.     }
  198.    
  199.     return counter;
  200. }
  201.  
  202.  
  203. /** Print number in given base
  204.  *
  205.  * Print significant digits of a number in given
  206.  * base.
  207.  *
  208.  * @param num  Number to print.
  209.  * @param width
  210.  * @param precision
  211.  * @param base Base to print the number in (should
  212.  *             be in range 2 .. 16).
  213.  * @param flags output modifiers
  214.  * @return number of printed characters
  215.  *
  216.  */
  217. static int print_number(uint64_t num, int width, int precision, int base , uint64_t flags, struct printf_spec *ps)
  218. {
  219.     char *digits = digits_small;
  220.     char d[PRINT_NUMBER_BUFFER_SIZE];   /* this is good enough even for base == 2, prefix and sign */
  221.     char *ptr = &d[PRINT_NUMBER_BUFFER_SIZE - 1];
  222.     int size = 0; /* size of number with all prefixes and signs */
  223.     int number_size; /* size of plain number */
  224.     char sgn;
  225.     int retval;
  226.     int counter = 0;
  227.    
  228.     if (flags & __PRINTF_FLAG_BIGCHARS)
  229.         digits = digits_big;   
  230.    
  231.     *ptr-- = 0; /* Put zero at end of string */
  232.  
  233.     if (num == 0) {
  234.         *ptr-- = '0';
  235.         size++;
  236.     } else {
  237.         do {
  238.             *ptr-- = digits[num % base];
  239.             size++;
  240.         } while (num /= base);
  241.     }
  242.    
  243.     number_size = size;
  244.  
  245.     /* Collect sum of all prefixes/signs/... to calculate padding and leading zeroes */
  246.     if (flags & __PRINTF_FLAG_PREFIX) {
  247.         switch(base) {
  248.         case 2: /* Binary formating is not standard, but usefull */
  249.             size += 2;
  250.             break;
  251.         case 8:
  252.             size++;
  253.             break;
  254.         case 16:
  255.             size += 2;
  256.             break;
  257.         }
  258.     }
  259.  
  260.     sgn = 0;
  261.     if (flags & __PRINTF_FLAG_SIGNED) {
  262.         if (flags & __PRINTF_FLAG_NEGATIVE) {
  263.             sgn = '-';
  264.             size++;
  265.         } else if (flags & __PRINTF_FLAG_SHOWPLUS) {
  266.                 sgn = '+';
  267.                 size++;
  268.             } else if (flags & __PRINTF_FLAG_SPACESIGN) {
  269.                     sgn = ' ';
  270.                     size++;
  271.                 }
  272.     }
  273.  
  274.     if (flags & __PRINTF_FLAG_LEFTALIGNED) {
  275.         flags &= ~__PRINTF_FLAG_ZEROPADDED;
  276.     }
  277.  
  278.     /* if number is leftaligned or precision is specified then zeropadding is ignored */
  279.     if (flags & __PRINTF_FLAG_ZEROPADDED) {
  280.         if ((precision == 0) && (width > size)) {
  281.             precision = width - size + number_size;
  282.         }
  283.     }
  284.  
  285.     /* print leading spaces */
  286.     if (number_size > precision) /* We must print whole number not only a part */
  287.         precision = number_size;
  288.  
  289.     width -= precision + size - number_size;
  290.    
  291.     if (!(flags & __PRINTF_FLAG_LEFTALIGNED)) {
  292.         while (width-- > 0) {  
  293.             if (printf_putchar(' ', ps) == 1)  
  294.                 counter++;
  295.         }
  296.     }
  297.    
  298.     /* print sign */
  299.     if (sgn) {
  300.         if (printf_putchar(sgn, ps) == 1)
  301.             counter++;
  302.     }
  303.    
  304.     /* print prefix */
  305.    
  306.     if (flags & __PRINTF_FLAG_PREFIX) {
  307.         switch(base) {
  308.         case 2: /* Binary formating is not standard, but usefull */
  309.             if (printf_putchar('0', ps) == 1)
  310.                 counter++;
  311.             if (flags & __PRINTF_FLAG_BIGCHARS) {
  312.                 if (printf_putchar('B', ps) == 1)
  313.                     counter++;
  314.             } else {
  315.                 if (printf_putchar('b', ps) == 1)
  316.                     counter++;
  317.             }
  318.             break;
  319.         case 8:
  320.             if (printf_putchar('o', ps) == 1)
  321.                 counter++;
  322.             break;
  323.         case 16:
  324.             if (printf_putchar('0', ps) == 1)
  325.                 counter++;
  326.             if (flags & __PRINTF_FLAG_BIGCHARS) {
  327.                 if (printf_putchar('X', ps) == 1)
  328.                     counter++;
  329.             } else {
  330.                 if (printf_putchar('x', ps) == 1)
  331.                     counter++;
  332.             }
  333.             break;
  334.         }
  335.     }
  336.  
  337.     /* print leading zeroes */
  338.     precision -= number_size;
  339.     while (precision-- > 0) {  
  340.         if (printf_putchar('0', ps) == 1)
  341.             counter++;
  342.     }
  343.  
  344.    
  345.     /* print number itself */
  346.  
  347.     if ((retval = printf_putstr(++ptr, ps)) > 0) {
  348.         counter += retval;
  349.     }
  350.    
  351.     /* print ending spaces */
  352.    
  353.     while (width-- > 0) {  
  354.         if (printf_putchar(' ', ps) == 1)  
  355.             counter++;
  356.     }
  357.  
  358.     return counter;
  359. }
  360.  
  361.  
  362. /** Print formatted string.
  363.  *
  364.  * Print string formatted according to the fmt parameter
  365.  * and variadic arguments. Each formatting directive
  366.  * must have the following form:
  367.  *
  368.  *  \% [ FLAGS ] [ WIDTH ] [ .PRECISION ] [ TYPE ] CONVERSION
  369.  *
  370.  * FLAGS:@n
  371.  *  - "#" Force to print prefix.
  372.  *  For conversion \%o the prefix is 0, for %x and \%X prefixes are 0x and 0X
  373.  *  and for conversion \%b the prefix is 0b.
  374.  *
  375.  *  - "-"   Align to left.
  376.  *
  377.  *  - "+"   Print positive sign just as negative.
  378.  *
  379.  *  - " "   If the printed number is positive and "+" flag is not set, print space in
  380.  *  place of sign.
  381.  *
  382.  *  - "0"   Print 0 as padding instead of spaces. Zeroes are placed between sign and the
  383.  *  rest of the number. This flag is ignored if "-" flag is specified.
  384.  *
  385.  * WIDTH:@n
  386.  *  - Specify minimal width of printed argument. If it is bigger, width is ignored.
  387.  * If width is specified with a "*" character instead of number, width is taken from
  388.  * parameter list. And integer parameter is expected before parameter for processed
  389.  * conversion specification. If this value is negative its absolute value is taken
  390.  * and the "-" flag is set.
  391.  *
  392.  * PRECISION:@n
  393.  *  - Value precision. For numbers it specifies minimum valid numbers.
  394.  * Smaller numbers are printed with leading zeroes. Bigger numbers are not affected.
  395.  * Strings with more than precision characters are cut off.
  396.  * Just as with width, an "*" can be used used instead of a number.
  397.  * An integer value is then expected in parameters. When both width and precision
  398.  * are specified using "*", the first parameter is used for width and the second one
  399.  * for precision.
  400.  *
  401.  * TYPE:@n
  402.  *  - "hh"  Signed or unsigned char.@n
  403.  *  - "h"   Signed or usigned short.@n
  404.  *  - ""    Signed or usigned int (default value).@n
  405.  *  - "l"   Signed or usigned long int.@n
  406.  *  - "ll"  Signed or usigned long long int.@n
  407.  *  - "z"   Type size_t.@n
  408.  *
  409.  *
  410.  * CONVERSION:@n
  411.  *  - % Print percentile character itself.
  412.  *
  413.  *  - c Print single character.
  414.  *
  415.  *  - s Print zero terminated string. If a NULL value is passed as value, "(NULL)" is printed instead.
  416.  *
  417.  *  - P, p  Print value of a pointer. Void * value is expected and it is printed in hexadecimal notation with prefix
  418.  *  (as with '\%#X' or '\%#x' for 32bit or '\%#X' or '\%#x' for 64bit long pointers).
  419.  *
  420.  *  - b Print value as unsigned binary number. Prefix is not printed by default. (Nonstandard extension.)
  421.  *
  422.  *  - o Print value as unsigned octal number. Prefix is not printed by default.
  423.  *
  424.  *  - d,i   Print signed decimal number. There is no difference between d and i conversion.
  425.  *
  426.  *  - u Print unsigned decimal number.
  427.  *
  428.  *  - X, x  Print hexadecimal number with upper- or lower-case. Prefix is not printed by default.
  429.  *
  430.  * All other characters from fmt except the formatting directives
  431.  * are printed in verbatim.
  432.  *
  433.  * @param fmt Formatting NULL terminated string.
  434.  * @return Number of printed characters or negative value on failure.
  435.  */
  436. int printf_core(const char *fmt, struct printf_spec *ps, va_list ap)
  437. {
  438.     int i = 0, j = 0; /* i is index of currently processed char from fmt, j is index to the first not printed nonformating character */
  439.     int end;
  440.     int counter; /* counter of printed characters */
  441.     int retval; /* used to store return values from called functions */
  442.     char c;
  443.     qualifier_t qualifier;  /* type of argument */
  444.     int base;   /* base in which will be parameter (numbers only) printed */
  445.     uint64_t number; /* argument value */
  446.     size_t  size; /* byte size of integer parameter */
  447.     int width, precision;
  448.     uint64_t flags;
  449.    
  450.     /* Don't let other threads interfere */
  451.     async_serialize_start();
  452.  
  453.     counter = 0;
  454.    
  455.     while ((c = fmt[i])) {
  456.         /* control character */
  457.         if (c == '%' ) {
  458.             /* print common characters if any processed */ 
  459.             if (i > j) {
  460.                 if ((retval = printf_putnchars(&fmt[j], (size_t)(i - j), ps)) < 0) { /* error */
  461.                     goto minus_out;
  462.                 }
  463.                 counter += retval;
  464.             }
  465.        
  466.             j = i;
  467.             /* parse modifiers */
  468.             flags = 0;
  469.             end = 0;
  470.            
  471.             do {
  472.                 ++i;
  473.                 switch (c = fmt[i]) {
  474.                 case '#': flags |= __PRINTF_FLAG_PREFIX; break;
  475.                 case '-': flags |= __PRINTF_FLAG_LEFTALIGNED; break;
  476.                 case '+': flags |= __PRINTF_FLAG_SHOWPLUS; break;
  477.                 case ' ': flags |= __PRINTF_FLAG_SPACESIGN; break;
  478.                 case '0': flags |= __PRINTF_FLAG_ZEROPADDED; break;
  479.                 default: end = 1;
  480.                 }; 
  481.                
  482.             } while (end == 0);
  483.            
  484.             /* width & '*' operator */
  485.             width = 0;
  486.             if (isdigit(fmt[i])) {
  487.                 while (isdigit(fmt[i])) {
  488.                     width *= 10;
  489.                     width += fmt[i++] - '0';
  490.                 }
  491.             } else if (fmt[i] == '*') {
  492.                 /* get width value from argument list*/
  493.                 i++;
  494.                 width = (int)va_arg(ap, int);
  495.                 if (width < 0) {
  496.                     /* negative width means to set '-' flag */
  497.                     width *= -1;
  498.                     flags |= __PRINTF_FLAG_LEFTALIGNED;
  499.                 }
  500.             }
  501.            
  502.             /* precision and '*' operator */   
  503.             precision = 0;
  504.             if (fmt[i] == '.') {
  505.                 ++i;
  506.                 if (isdigit(fmt[i])) {
  507.                     while (isdigit(fmt[i])) {
  508.                         precision *= 10;
  509.                         precision += fmt[i++] - '0';
  510.                     }
  511.                 } else if (fmt[i] == '*') {
  512.                     /* get precision value from argument list*/
  513.                     i++;
  514.                     precision = (int)va_arg(ap, int);
  515.                     if (precision < 0) {
  516.                         /* negative precision means to ignore it */
  517.                         precision = 0;
  518.                     }
  519.                 }
  520.             }
  521.  
  522.             switch (fmt[i++]) {
  523.             /** TODO: unimplemented qualifiers:
  524.              * t ptrdiff_t - ISO C 99
  525.              */
  526.             case 'h':   /* char or short */
  527.                 qualifier = PrintfQualifierShort;
  528.                 if (fmt[i] == 'h') {
  529.                     i++;
  530.                     qualifier = PrintfQualifierByte;
  531.                 }
  532.                 break;
  533.             case 'l':   /* long or long long*/
  534.                 qualifier = PrintfQualifierLong;
  535.                 if (fmt[i] == 'l') {
  536.                     i++;
  537.                     qualifier = PrintfQualifierLongLong;
  538.                 }
  539.                 break;
  540.             case 'z':   /* size_t */
  541.                 qualifier = PrintfQualifierSizeT;
  542.                 break;
  543.             default:
  544.                 qualifier = PrintfQualifierInt; /* default type */
  545.                 --i;
  546.             }  
  547.            
  548.             base = 10;
  549.  
  550.             switch (c = fmt[i]) {
  551.  
  552.                 /*
  553.                 * String and character conversions.
  554.                 */
  555.             case 's':
  556.                 if ((retval = print_string(va_arg(ap, char*), width, precision, flags, ps)) < 0) {
  557.                     goto minus_out;
  558.                 }
  559.                    
  560.                 counter += retval;
  561.                 j = i + 1;
  562.                 goto next_char;
  563.             case 'c':
  564.                 c = va_arg(ap, unsigned int);
  565.                 if ((retval = print_char(c, width, flags, ps)) < 0) {
  566.                     goto minus_out;
  567.                 }
  568.  
  569.                 counter += retval;
  570.                 j = i + 1;
  571.                 goto next_char;
  572.  
  573.             /*
  574.              * Integer values
  575.             */
  576.             case 'P': /* pointer */
  577.                     flags |= __PRINTF_FLAG_BIGCHARS;
  578.             case 'p':
  579.                 flags |= __PRINTF_FLAG_PREFIX;
  580.                 base = 16;
  581.                 qualifier = PrintfQualifierPointer;
  582.                 break; 
  583.             case 'b':
  584.                 base = 2;
  585.                 break;
  586.             case 'o':
  587.                 base = 8;
  588.                 break;
  589.             case 'd':
  590.             case 'i':
  591.                 flags |= __PRINTF_FLAG_SIGNED;  
  592.             case 'u':
  593.                 break;
  594.             case 'X':
  595.                 flags |= __PRINTF_FLAG_BIGCHARS;
  596.             case 'x':
  597.                 base = 16;
  598.                 break;
  599.             /* percentile itself */
  600.             case '%':
  601.                 j = i;
  602.                 goto next_char;
  603.             /*
  604.             * Bad formatting.
  605.             */
  606.             default:
  607.                 /* Unknown format
  608.                  *  now, the j is index of '%' so we will
  609.                  * print whole bad format sequence
  610.                  */
  611.                 goto next_char;    
  612.             }
  613.        
  614.        
  615.         /* Print integers */
  616.             /* print number */
  617.             switch (qualifier) {
  618.             case PrintfQualifierByte:
  619.                 size = sizeof(unsigned char);
  620.                 number = (uint64_t)va_arg(ap, unsigned int);
  621.                 break;
  622.             case PrintfQualifierShort:
  623.                 size = sizeof(unsigned short);
  624.                 number = (uint64_t)va_arg(ap, unsigned int);
  625.                 break;
  626.             case PrintfQualifierInt:
  627.                 size = sizeof(unsigned int);
  628.                 number = (uint64_t)va_arg(ap, unsigned int);
  629.                 break;
  630.             case PrintfQualifierLong:
  631.                 size = sizeof(unsigned long);
  632.                 number = (uint64_t)va_arg(ap, unsigned long);
  633.                 break;
  634.             case PrintfQualifierLongLong:
  635.                 size = sizeof(unsigned long long);
  636.                 number = (uint64_t)va_arg(ap, unsigned long long);
  637.                 break;
  638.             case PrintfQualifierPointer:
  639.                 size = sizeof(void *);
  640.                 number = (uint64_t)(unsigned long)va_arg(ap, void *);
  641.                 break;
  642.             case PrintfQualifierSizeT:
  643.                 size = sizeof(size_t);
  644.                 number = (uint64_t)va_arg(ap, size_t);
  645.                 break;
  646.             default: /* Unknown qualifier */
  647.                 goto minus_out;
  648.                    
  649.             }
  650.            
  651.             if (flags & __PRINTF_FLAG_SIGNED) {
  652.                 if (number & (0x1 << (size*8 - 1))) {
  653.                     flags |= __PRINTF_FLAG_NEGATIVE;
  654.                
  655.                     if (size == sizeof(uint64_t)) {
  656.                         number = -((int64_t)number);
  657.                     } else {
  658.                         number = ~number;
  659.                         number &= (~((0xFFFFFFFFFFFFFFFFll) <<  (size * 8)));
  660.                         number++;
  661.                     }
  662.                 }
  663.             }
  664.  
  665.             if ((retval = print_number(number, width, precision, base, flags, ps)) < 0 ) {
  666.                 goto minus_out;
  667.             };
  668.  
  669.             counter += retval;
  670.             j = i + 1;
  671.         }  
  672. next_char:
  673.            
  674.         ++i;
  675.     }
  676.    
  677.     if (i > j) {
  678.         if ((retval = printf_putnchars(&fmt[j], (size_t)(i - j), ps)) < 0) { /* error */
  679.             goto minus_out;
  680.         }
  681.         counter += retval;
  682.     }
  683.    
  684.     async_serialize_end();
  685.     return counter;
  686. minus_out:
  687.     async_serialize_end();
  688.     return -counter;
  689. }
  690.  
  691. /** @}
  692.  */
  693.