Subversion Repositories HelenOS-historic

Rev

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