Subversion Repositories HelenOS

Rev

Rev 2131 | Go to most recent revision | Details | Compare with Previous | Last modification | View Log | RSS feed

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