Subversion Repositories HelenOS

Rev

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

Rev Author Line No. Line
1271 cejka 1
/*
2071 jermar 2
 * Copyright (c) 2001-2004 Jakub Jermar
3
 * Copyright (c) 2006 Josef Cejka
4180 decky 4
 * Copyright (c) 2009 Martin Decky
1271 cejka 5
 * All rights reserved.
6
 *
7
 * Redistribution and use in source and binary forms, with or without
8
 * modification, are permitted provided that the following conditions
9
 * are met:
10
 *
11
 * - Redistributions of source code must retain the above copyright
12
 *   notice, this list of conditions and the following disclaimer.
13
 * - Redistributions in binary form must reproduce the above copyright
14
 *   notice, this list of conditions and the following disclaimer in the
15
 *   documentation and/or other materials provided with the distribution.
16
 * - The name of the author may not be used to endorse or promote products
17
 *   derived from this software without specific prior written permission.
18
 *
19
 * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR
20
 * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
21
 * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
22
 * IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT,
23
 * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
24
 * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
25
 * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
26
 * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
27
 * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
28
 * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
29
 */
30
 
4180 decky 31
/** @addtogroup generic
1702 cejka 32
 * @{
33
 */
1271 cejka 34
/**
1702 cejka 35
 * @file
4180 decky 36
 * @brief Printing functions.
1271 cejka 37
 */
38
 
39
#include <printf/printf_core.h>
40
#include <print.h>
41
#include <arch/arg.h>
2572 jermar 42
#include <macros.h>
4011 svoboda 43
#include <string.h>
1271 cejka 44
#include <arch.h>
45
 
2572 jermar 46
/** show prefixes 0x or 0 */
4180 decky 47
#define __PRINTF_FLAG_PREFIX       0x00000001
2572 jermar 48
/** signed / unsigned number */
4180 decky 49
#define __PRINTF_FLAG_SIGNED       0x00000002
2572 jermar 50
/** print leading zeroes */
4180 decky 51
#define __PRINTF_FLAG_ZEROPADDED   0x00000004
2572 jermar 52
/** align to left */
4180 decky 53
#define __PRINTF_FLAG_LEFTALIGNED  0x00000010
2572 jermar 54
/** always show + sign */
4180 decky 55
#define __PRINTF_FLAG_SHOWPLUS     0x00000020
2572 jermar 56
/** print space instead of plus */
4180 decky 57
#define __PRINTF_FLAG_SPACESIGN    0x00000040
2572 jermar 58
/** show big characters */
4180 decky 59
#define __PRINTF_FLAG_BIGCHARS     0x00000080
2572 jermar 60
/** number has - sign */
4180 decky 61
#define __PRINTF_FLAG_NEGATIVE     0x00000100
1271 cejka 62
 
2572 jermar 63
/**
64
 * Buffer big enough for 64-bit number printed in base 2, sign, prefix and 0
65
 * to terminate string... (last one is only for better testing end of buffer by
66
 * zero-filling subroutine)
67
 */
4180 decky 68
#define PRINT_NUMBER_BUFFER_SIZE  (64 + 5)
1271 cejka 69
 
70
/** Enumeration of possible arguments types.
71
 */
72
typedef enum {
73
    PrintfQualifierByte = 0,
74
    PrintfQualifierShort,
75
    PrintfQualifierInt,
76
    PrintfQualifierLong,
77
    PrintfQualifierLongLong,
78
    PrintfQualifierPointer
79
} qualifier_t;
80
 
4180 decky 81
static char nullstr[] = "(NULL)";
2572 jermar 82
static char digits_small[] = "0123456789abcdef";
83
static char digits_big[] = "0123456789ABCDEF";
1271 cejka 84
 
4213 decky 85
/** Print one or more characters without adding newline.
2572 jermar 86
 *
4213 decky 87
 * @param buf  Buffer holding characters with size of
4180 decky 88
 *             at least size bytes. NULL is not allowed!
89
 * @param size Size of the buffer in bytes.
90
 * @param ps   Output method and its data.
91
 *
4213 decky 92
 * @return Number of characters printed.
4180 decky 93
 *
1271 cejka 94
 */
4213 decky 95
static int printf_putnchars(const char *buf, size_t size,
4180 decky 96
    printf_spec_t *ps)
1271 cejka 97
{
4213 decky 98
    return ps->str_write((void *) buf, size, ps->data);
1271 cejka 99
}
100
 
4213 decky 101
/** Print one or more wide characters without adding newline.
2572 jermar 102
 *
4213 decky 103
 * @param buf  Buffer holding wide characters with size of
4180 decky 104
 *             at least size bytes. NULL is not allowed!
105
 * @param size Size of the buffer in bytes.
106
 * @param ps   Output method and its data.
107
 *
4213 decky 108
 * @return Number of wide characters printed.
4180 decky 109
 *
1271 cejka 110
 */
4213 decky 111
static int printf_wputnchars(const wchar_t *buf, size_t size,
4180 decky 112
    printf_spec_t *ps)
1271 cejka 113
{
4213 decky 114
    return ps->wstr_write((void *) buf, size, ps->data);
4180 decky 115
}
116
 
4213 decky 117
/** Print string without adding a newline.
4180 decky 118
 *
4213 decky 119
 * @param str String to print.
120
 * @param ps  Write function specification and support data.
4180 decky 121
 *
4210 svoboda 122
 * @return Number of characters printed.
4180 decky 123
 *
124
 */
125
static int printf_putstr(const char *str, printf_spec_t *ps)
126
{
127
    if (str == NULL)
4213 decky 128
        return printf_putnchars(nullstr, str_size(nullstr), ps);
1271 cejka 129
 
4213 decky 130
    return ps->str_write((void *) str, str_size(str), ps->data);
4180 decky 131
}
1271 cejka 132
 
4180 decky 133
/** Print one ASCII character.
134
 *
135
 * @param c  ASCII character to be printed.
136
 * @param ps Output method.
137
 *
138
 * @return Number of characters printed.
139
 *
140
 */
141
static int printf_putchar(const char ch, printf_spec_t *ps)
142
{
143
    if (!ascii_check(ch))
4213 decky 144
        return ps->str_write((void *) &invalch, 1, ps->data);
4180 decky 145
 
4213 decky 146
    return ps->str_write(&ch, 1, ps->data);
1271 cejka 147
}
148
 
4213 decky 149
/** Print one wide character.
2572 jermar 150
 *
4213 decky 151
 * @param c  Wide character to be printed.
4180 decky 152
 * @param ps Output method.
2572 jermar 153
 *
4180 decky 154
 * @return Number of characters printed.
155
 *
1271 cejka 156
 */
4180 decky 157
static int printf_putwchar(const wchar_t ch, printf_spec_t *ps)
1271 cejka 158
{
4213 decky 159
    if (!chr_check(ch))
160
        return ps->str_write((void *) &invalch, 1, ps->data);
1271 cejka 161
 
4213 decky 162
    return ps->wstr_write(&ch, sizeof(wchar_t), ps->data);
1271 cejka 163
}
164
 
4180 decky 165
/** Print one formatted ASCII character.
2572 jermar 166
 *
4180 decky 167
 * @param ch    Character to print.
168
 * @param width Width modifier.
169
 * @param flags Flags that change the way the character is printed.
2572 jermar 170
 *
4180 decky 171
 * @return Number of characters printed, negative value on failure.
172
 *
1271 cejka 173
 */
4180 decky 174
static int print_char(const char ch, int width, uint32_t flags, printf_spec_t *ps)
1271 cejka 175
{
4180 decky 176
    count_t counter = 0;
1271 cejka 177
    if (!(flags & __PRINTF_FLAG_LEFTALIGNED)) {
2572 jermar 178
        while (--width > 0) {
179
            /*
180
             * One space is consumed by the character itself, hence
181
             * the predecrement.
182
             */
4180 decky 183
            if (printf_putchar(' ', ps) > 0)
184
                counter++;
1271 cejka 185
        }
186
    }
187
 
4180 decky 188
    if (printf_putchar(ch, ps) > 0)
1604 cejka 189
        counter++;
4180 decky 190
 
191
    while (--width > 0) {
192
        /*
193
         * One space is consumed by the character itself, hence
194
         * the predecrement.
195
         */
196
        if (printf_putchar(' ', ps) > 0)
197
            counter++;
198
    }
199
 
200
    return (int) (counter + 1);
201
}
1271 cejka 202
 
4213 decky 203
/** Print one formatted wide character.
4180 decky 204
 *
205
 * @param ch    Character to print.
206
 * @param width Width modifier.
207
 * @param flags Flags that change the way the character is printed.
208
 *
209
 * @return Number of characters printed, negative value on failure.
210
 *
211
 */
212
static int print_wchar(const wchar_t ch, int width, uint32_t flags, printf_spec_t *ps)
213
{
214
    count_t counter = 0;
215
    if (!(flags & __PRINTF_FLAG_LEFTALIGNED)) {
216
        while (--width > 0) {
2572 jermar 217
            /*
218
             * One space is consumed by the character itself, hence
219
             * the predecrement.
220
             */
4180 decky 221
            if (printf_putchar(' ', ps) > 0)
222
                counter++;
223
        }
224
    }
225
 
226
    if (printf_putwchar(ch, ps) > 0)
227
        counter++;
228
 
229
    while (--width > 0) {
230
        /*
231
         * One space is consumed by the character itself, hence
232
         * the predecrement.
233
         */
1604 cejka 234
        if (printf_putchar(' ', ps) > 0)
4180 decky 235
            counter++;
1271 cejka 236
    }
237
 
4180 decky 238
    return (int) (counter + 1);
1271 cejka 239
}
240
 
4213 decky 241
/** Print string.
2572 jermar 242
 *
4210 svoboda 243
 * @param str       String to be printed.
4180 decky 244
 * @param width     Width modifier.
245
 * @param precision Precision modifier.
246
 * @param flags     Flags that modify the way the string is printed.
2572 jermar 247
 *
4210 svoboda 248
 * @return Number of characters printed, negative value on failure.
4180 decky 249
 */
4210 svoboda 250
static int print_str(char *str, int width, unsigned int precision,
4180 decky 251
    uint32_t flags, printf_spec_t *ps)
1271 cejka 252
{
4180 decky 253
    if (str == NULL)
254
        return printf_putstr(nullstr, ps);
4206 svoboda 255
 
256
    /* Print leading spaces. */
257
    count_t strw = str_length(str);
4180 decky 258
    if (precision == 0)
4206 svoboda 259
        precision = strw;
4199 svoboda 260
 
4210 svoboda 261
    /* Left padding */
4180 decky 262
    count_t counter = 0;
263
    width -= precision;
264
    if (!(flags & __PRINTF_FLAG_LEFTALIGNED)) {
265
        while (width-- > 0) {
266
            if (printf_putchar(' ', ps) == 1)
267
                counter++;
268
        }
269
    }
4199 svoboda 270
 
4210 svoboda 271
    /* Part of @a str fitting into the alloted space. */
1604 cejka 272
    int retval;
4213 decky 273
    size_t size = str_lsize(str, precision);
274
    if ((retval = printf_putnchars(str, size, ps)) < 0)
4180 decky 275
        return -counter;
4206 svoboda 276
 
4180 decky 277
    counter += retval;
4206 svoboda 278
 
4210 svoboda 279
    /* Right padding */
4180 decky 280
    while (width-- > 0) {
281
        if (printf_putchar(' ', ps) == 1)
282
            counter++;
1271 cejka 283
    }
4199 svoboda 284
 
4180 decky 285
    return ((int) counter);
4206 svoboda 286
 
4180 decky 287
}
1271 cejka 288
 
4213 decky 289
/** Print wide string.
4180 decky 290
 *
4213 decky 291
 * @param str       Wide string to be printed.
292
 * @param width     Width modifier.
293
 * @param precision Precision modifier.
294
 * @param flags     Flags that modify the way the string is printed.
4180 decky 295
 *
4213 decky 296
 * @return Number of wide characters printed, negative value on failure.
4180 decky 297
 */
4213 decky 298
static int print_wstr(wchar_t *str, int width, unsigned int precision,
4180 decky 299
    uint32_t flags, printf_spec_t *ps)
300
{
4213 decky 301
    if (str == NULL)
4180 decky 302
        return printf_putstr(nullstr, ps);
4206 svoboda 303
 
304
    /* Print leading spaces. */
4213 decky 305
    size_t strw = wstr_length(str);
4180 decky 306
    if (precision == 0)
4206 svoboda 307
        precision = strw;
308
 
4210 svoboda 309
    /* Left padding */
4180 decky 310
    count_t counter = 0;
1271 cejka 311
    width -= precision;
312
    if (!(flags & __PRINTF_FLAG_LEFTALIGNED)) {
4180 decky 313
        while (width-- > 0) {
314
            if (printf_putchar(' ', ps) == 1)
1604 cejka 315
                counter++;
1271 cejka 316
        }
317
    }
4206 svoboda 318
 
4210 svoboda 319
    /* Part of @a wstr fitting into the alloted space. */
4180 decky 320
    int retval;
4213 decky 321
    size_t size = wstr_lsize(str, precision);
322
    if ((retval = printf_wputnchars(str, size, ps)) < 0)
1604 cejka 323
        return -counter;
4206 svoboda 324
 
4180 decky 325
    counter += retval;
4206 svoboda 326
 
4210 svoboda 327
    /* Right padding */
1271 cejka 328
    while (width-- > 0) {
4180 decky 329
        if (printf_putchar(' ', ps) == 1)
330
            counter++;
1271 cejka 331
    }
4206 svoboda 332
 
4180 decky 333
    return ((int) counter);
1271 cejka 334
}
335
 
2572 jermar 336
/** Print a number in a given base.
1271 cejka 337
 *
2572 jermar 338
 * Print significant digits of a number in given base.
1271 cejka 339
 *
4180 decky 340
 * @param num       Number to print.
341
 * @param width     Width modifier.
342
 * @param precision Precision modifier.
343
 * @param base      Base to print the number in (must be between 2 and 16).
344
 * @param flags     Flags that modify the way the number is printed.
1271 cejka 345
 *
4180 decky 346
 * @return Number of characters printed.
2572 jermar 347
 *
1271 cejka 348
 */
2572 jermar 349
static int print_number(uint64_t num, int width, int precision, int base,
4180 decky 350
    uint32_t flags, printf_spec_t *ps)
1271 cejka 351
{
4180 decky 352
    char *digits;
353
    if (flags & __PRINTF_FLAG_BIGCHARS)
354
        digits = digits_big;
355
    else
356
        digits = digits_small;
1271 cejka 357
 
4180 decky 358
    char data[PRINT_NUMBER_BUFFER_SIZE];
359
    char *ptr = &data[PRINT_NUMBER_BUFFER_SIZE - 1];
1271 cejka 360
 
4180 decky 361
    /* Size of number with all prefixes and signs */
362
    int size = 0;
363
 
364
    /* Put zero at end of string */
365
    *ptr-- = 0;
366
 
1271 cejka 367
    if (num == 0) {
368
        *ptr-- = '0';
369
        size++;
370
    } else {
371
        do {
372
            *ptr-- = digits[num % base];
373
            size++;
374
        } while (num /= base);
375
    }
376
 
4180 decky 377
    /* Size of plain number */
378
    int number_size = size;
379
 
2572 jermar 380
    /*
4180 decky 381
     * Collect the sum of all prefixes/signs/etc. to calculate padding and
2572 jermar 382
     * leading zeroes.
383
     */
1271 cejka 384
    if (flags & __PRINTF_FLAG_PREFIX) {
385
        switch(base) {
4180 decky 386
        case 2:
387
            /* Binary formating is not standard, but usefull */
2070 jermar 388
            size += 2;
389
            break;
390
        case 8:
391
            size++;
392
            break;
393
        case 16:
394
            size += 2;
395
            break;
1271 cejka 396
        }
397
    }
4180 decky 398
 
399
    char sgn = 0;
1271 cejka 400
    if (flags & __PRINTF_FLAG_SIGNED) {
401
        if (flags & __PRINTF_FLAG_NEGATIVE) {
402
            sgn = '-';
403
            size++;
404
        } else if (flags & __PRINTF_FLAG_SHOWPLUS) {
2572 jermar 405
            sgn = '+';
406
            size++;
407
        } else if (flags & __PRINTF_FLAG_SPACESIGN) {
408
            sgn = ' ';
409
            size++;
410
        }
1271 cejka 411
    }
4180 decky 412
 
413
    if (flags & __PRINTF_FLAG_LEFTALIGNED)
1271 cejka 414
        flags &= ~__PRINTF_FLAG_ZEROPADDED;
4180 decky 415
 
2572 jermar 416
    /*
4180 decky 417
     * If the number is left-aligned or precision is specified then
418
     * padding with zeros is ignored.
2572 jermar 419
     */
1271 cejka 420
    if (flags & __PRINTF_FLAG_ZEROPADDED) {
4180 decky 421
        if ((precision == 0) && (width > size))
1271 cejka 422
            precision = width - size + number_size;
423
    }
4180 decky 424
 
4213 decky 425
    /* Print leading spaces */
2572 jermar 426
    if (number_size > precision) {
4213 decky 427
        /* Print the whole number, not only a part */
1271 cejka 428
        precision = number_size;
2572 jermar 429
    }
4180 decky 430
 
1271 cejka 431
    width -= precision + size - number_size;
4180 decky 432
    count_t counter = 0;
1271 cejka 433
 
434
    if (!(flags & __PRINTF_FLAG_LEFTALIGNED)) {
4180 decky 435
        while (width-- > 0) {
436
            if (printf_putchar(' ', ps) == 1)
1604 cejka 437
                counter++;
1271 cejka 438
        }
439
    }
440
 
4213 decky 441
    /* Print sign */
1271 cejka 442
    if (sgn) {
1604 cejka 443
        if (printf_putchar(sgn, ps) == 1)
444
            counter++;
1271 cejka 445
    }
446
 
4213 decky 447
    /* Print prefix */
1271 cejka 448
    if (flags & __PRINTF_FLAG_PREFIX) {
449
        switch(base) {
4180 decky 450
        case 2:
451
            /* Binary formating is not standard, but usefull */
2070 jermar 452
            if (printf_putchar('0', ps) == 1)
453
                counter++;
454
            if (flags & __PRINTF_FLAG_BIGCHARS) {
455
                if (printf_putchar('B', ps) == 1)
1604 cejka 456
                    counter++;
2070 jermar 457
            } else {
458
                if (printf_putchar('b', ps) == 1)
1604 cejka 459
                    counter++;
2070 jermar 460
            }
461
            break;
462
        case 8:
463
            if (printf_putchar('o', ps) == 1)
464
                counter++;
465
            break;
466
        case 16:
467
            if (printf_putchar('0', ps) == 1)
468
                counter++;
469
            if (flags & __PRINTF_FLAG_BIGCHARS) {
470
                if (printf_putchar('X', ps) == 1)
1604 cejka 471
                    counter++;
2070 jermar 472
            } else {
473
                if (printf_putchar('x', ps) == 1)
474
                    counter++;
475
            }
476
            break;
1271 cejka 477
        }
478
    }
4180 decky 479
 
4213 decky 480
    /* Print leading zeroes */
1271 cejka 481
    precision -= number_size;
4180 decky 482
    while (precision-- > 0) {
1604 cejka 483
        if (printf_putchar('0', ps) == 1)
484
            counter++;
1271 cejka 485
    }
486
 
4213 decky 487
    /* Print the number itself */
4180 decky 488
    int retval;
489
    if ((retval = printf_putstr(++ptr, ps)) > 0)
1604 cejka 490
        counter += retval;
1271 cejka 491
 
4213 decky 492
    /* Print tailing spaces */
1271 cejka 493
 
4180 decky 494
    while (width-- > 0) {
495
        if (printf_putchar(' ', ps) == 1)
1604 cejka 496
            counter++;
1271 cejka 497
    }
4180 decky 498
 
499
    return ((int) counter);
1271 cejka 500
}
501
 
502
/** Print formatted string.
503
 *
2572 jermar 504
 * Print string formatted according to the fmt parameter and variadic arguments.
505
 * Each formatting directive must have the following form:
1271 cejka 506
 *
4180 decky 507
 *  \% [ FLAGS ] [ WIDTH ] [ .PRECISION ] [ TYPE ] CONVERSION
508
 *
1271 cejka 509
 * FLAGS:@n
4180 decky 510
 *  - "#" Force to print prefix. For \%o conversion, the prefix is 0, for
511
 *        \%x and \%X prefixes are 0x and 0X and for conversion \%b the
512
 *        prefix is 0b.
1271 cejka 513
 *
4180 decky 514
 *  - "-" Align to left.
1271 cejka 515
 *
4180 decky 516
 *  - "+" Print positive sign just as negative.
1271 cejka 517
 *
4180 decky 518
 *  - " " If the printed number is positive and "+" flag is not set,
519
 *        print space in place of sign.
1271 cejka 520
 *
4180 decky 521
 *  - "0" Print 0 as padding instead of spaces. Zeroes are placed between
522
 *        sign and the rest of the number. This flag is ignored if "-"
523
 *        flag is specified.
524
 *
1271 cejka 525
 * WIDTH:@n
4180 decky 526
 *  - Specify the minimal width of a printed argument. If it is bigger,
527
 *    width is ignored. If width is specified with a "*" character instead of
528
 *    number, width is taken from parameter list. And integer parameter is
529
 *    expected before parameter for processed conversion specification. If
530
 *    this value is negative its absolute value is taken and the "-" flag is
531
 *    set.
1271 cejka 532
 *
533
 * PRECISION:@n
4180 decky 534
 *  - Value precision. For numbers it specifies minimum valid numbers.
535
 *    Smaller numbers are printed with leading zeroes. Bigger numbers are not
536
 *    affected. Strings with more than precision characters are cut off. Just
537
 *    as with width, an "*" can be used used instead of a number. An integer
538
 *    value is then expected in parameters. When both width and precision are
539
 *    specified using "*", the first parameter is used for width and the
540
 *    second one for precision.
541
 *
1271 cejka 542
 * TYPE:@n
4180 decky 543
 *  - "hh" Signed or unsigned char.@n
544
 *  - "h"  Signed or unsigned short.@n
545
 *  - ""   Signed or unsigned int (default value).@n
546
 *  - "l"  Signed or unsigned long int.@n
4213 decky 547
 *         If conversion is "c", the character is wchar_t (wide character).@n
548
 *         If conversion is "s", the string is wchar_t * (wide string).@n
4180 decky 549
 *  - "ll" Signed or unsigned long long int.@n
550
 *
1271 cejka 551
 * CONVERSION:@n
4180 decky 552
 *  - % Print percentile character itself.
1271 cejka 553
 *
4180 decky 554
 *  - c Print single character. The character is expected to be plain
555
 *      ASCII (e.g. only values 0 .. 127 are valid).@n
4213 decky 556
 *      If type is "l", then the character is expected to be wide character
4180 decky 557
 *      (e.g. values 0 .. 0x10ffff are valid).
1271 cejka 558
 *
4180 decky 559
 *  - s Print zero terminated string. If a NULL value is passed as
560
 *      value, "(NULL)" is printed instead.@n
4213 decky 561
 *      If type is "l", then the string is expected to be wide string.
1271 cejka 562
 *
4180 decky 563
 *  - P, p Print value of a pointer. Void * value is expected and it is
564
 *         printed in hexadecimal notation with prefix (as with \%#X / \%#x
565
 *         for 32-bit or \%#X / \%#x for 64-bit long pointers).
1271 cejka 566
 *
4180 decky 567
 *  - b Print value as unsigned binary number. Prefix is not printed by
568
 *      default. (Nonstandard extension.)
1271 cejka 569
 *
4180 decky 570
 *  - o Print value as unsigned octal number. Prefix is not printed by
571
 *      default.
1271 cejka 572
 *
4180 decky 573
 *  - d, i Print signed decimal number. There is no difference between d
574
 *         and i conversion.
575
 *
576
 *  - u Print unsigned decimal number.
577
 *
578
 *  - X, x Print hexadecimal number with upper- or lower-case. Prefix is
579
 *         not printed by default.
580
 *
4210 svoboda 581
 * All other characters from fmt except the formatting directives are printed
2572 jermar 582
 * verbatim.
1271 cejka 583
 *
4213 decky 584
 * @param fmt Format NULL-terminated string.
585
 *
4210 svoboda 586
 * @return Number of characters printed, negative value on failure.
4180 decky 587
 *
1271 cejka 588
 */
4180 decky 589
int printf_core(const char *fmt, printf_spec_t *ps, va_list ap)
1271 cejka 590
{
4213 decky 591
    size_t i;        /* Index of the currently processed character from fmt */
592
    size_t nxt = 0;  /* Index of the next character from fmt */
593
    size_t j = 0;    /* Index to the first not printed nonformating character */
1271 cejka 594
 
4210 svoboda 595
    count_t counter = 0;  /* Number of characters printed */
4180 decky 596
    int retval;           /* Return values from nested functions */
597
 
4199 svoboda 598
    while (true) {
599
        i = nxt;
4213 decky 600
        wchar_t uc = str_decode(fmt, &nxt, STR_NO_LIMIT);
601
 
602
        if (uc == 0)
603
            break;
604
 
4180 decky 605
        /* Control character */
606
        if (uc == '%') {
607
            /* Print common characters if any processed */
1271 cejka 608
            if (i > j) {
4213 decky 609
                if ((retval = printf_putnchars(&fmt[j], i - j, ps)) < 0) {
4180 decky 610
                    /* Error */
1271 cejka 611
                    counter = -counter;
612
                    goto out;
613
                }
614
                counter += retval;
615
            }
4180 decky 616
 
1271 cejka 617
            j = i;
618
 
4180 decky 619
            /* Parse modifiers */
620
            uint32_t flags = 0;
621
            bool end = false;
622
 
1271 cejka 623
            do {
4199 svoboda 624
                i = nxt;
4213 decky 625
                uc = str_decode(fmt, &nxt, STR_NO_LIMIT);
4183 decky 626
                switch (uc) {
2572 jermar 627
                case '#':
628
                    flags |= __PRINTF_FLAG_PREFIX;
629
                    break;
630
                case '-':
631
                    flags |= __PRINTF_FLAG_LEFTALIGNED;
632
                    break;
633
                case '+':
634
                    flags |= __PRINTF_FLAG_SHOWPLUS;
635
                    break;
636
                case ' ':
637
                    flags |= __PRINTF_FLAG_SPACESIGN;
638
                    break;
639
                case '0':
640
                    flags |= __PRINTF_FLAG_ZEROPADDED;
641
                    break;
642
                default:
4180 decky 643
                    end = true;
644
                };
645
            } while (!end);
1271 cejka 646
 
4180 decky 647
            /* Width & '*' operator */
648
            int width = 0;
649
            if (isdigit(uc)) {
4199 svoboda 650
                while (true) {
651
                    width *= 10;
652
                    width += uc - '0';
4213 decky 653
 
4199 svoboda 654
                    i = nxt;
4213 decky 655
                    uc = str_decode(fmt, &nxt, STR_NO_LIMIT);
656
                    if (uc == 0)
4199 svoboda 657
                        break;
4180 decky 658
                    if (!isdigit(uc))
659
                        break;
1271 cejka 660
                }
4180 decky 661
            } else if (uc == '*') {
662
                /* Get width value from argument list */
4199 svoboda 663
                i = nxt;
4213 decky 664
                uc = str_decode(fmt, &nxt, STR_NO_LIMIT);
3058 decky 665
                width = (int) va_arg(ap, int);
1271 cejka 666
                if (width < 0) {
4180 decky 667
                    /* Negative width sets '-' flag */
1271 cejka 668
                    width *= -1;
669
                    flags |= __PRINTF_FLAG_LEFTALIGNED;
670
                }
671
            }
672
 
4180 decky 673
            /* Precision and '*' operator */
674
            int precision = 0;
675
            if (uc == '.') {
4199 svoboda 676
                i = nxt;
4213 decky 677
                uc = str_decode(fmt, &nxt, STR_NO_LIMIT);
4180 decky 678
                if (isdigit(uc)) {
4199 svoboda 679
                    while (true) {
680
                        precision *= 10;
681
                        precision += uc - '0';
4213 decky 682
 
4199 svoboda 683
                        i = nxt;
4213 decky 684
                        uc = str_decode(fmt, &nxt, STR_NO_LIMIT);
685
                        if (uc == 0)
4199 svoboda 686
                            break;
4180 decky 687
                        if (!isdigit(uc))
688
                            break;
1271 cejka 689
                    }
4199 svoboda 690
                } else if (uc == '*') {
4180 decky 691
                    /* Get precision value from the argument list */
4199 svoboda 692
                    i = nxt;
4213 decky 693
                    uc = str_decode(fmt, &nxt, STR_NO_LIMIT);
3058 decky 694
                    precision = (int) va_arg(ap, int);
1271 cejka 695
                    if (precision < 0) {
4180 decky 696
                        /* Ignore negative precision */
1271 cejka 697
                        precision = 0;
698
                    }
699
                }
700
            }
4180 decky 701
 
702
            qualifier_t qualifier;
703
 
704
            switch (uc) {
705
            /** @todo Unimplemented qualifiers:
706
             *        t ptrdiff_t - ISO C 99
1888 jermar 707
             */
4180 decky 708
            case 'h':
709
                /* Char or short */
1888 jermar 710
                qualifier = PrintfQualifierShort;
4199 svoboda 711
                i = nxt;
4213 decky 712
                uc = str_decode(fmt, &nxt, STR_NO_LIMIT);
4180 decky 713
                if (uc == 'h') {
4199 svoboda 714
                    i = nxt;
4213 decky 715
                    uc = str_decode(fmt, &nxt, STR_NO_LIMIT);
1888 jermar 716
                    qualifier = PrintfQualifierByte;
717
                }
718
                break;
4180 decky 719
            case 'l':
720
                /* Long or long long */
1888 jermar 721
                qualifier = PrintfQualifierLong;
4199 svoboda 722
                i = nxt;
4213 decky 723
                uc = str_decode(fmt, &nxt, STR_NO_LIMIT);
4180 decky 724
                if (uc == 'l') {
4199 svoboda 725
                    i = nxt;
4213 decky 726
                    uc = str_decode(fmt, &nxt, STR_NO_LIMIT);
1888 jermar 727
                    qualifier = PrintfQualifierLongLong;
728
                }
729
                break;
730
            default:
4180 decky 731
                /* Default type */
732
                qualifier = PrintfQualifierInt;
733
            }
1271 cejka 734
 
4180 decky 735
            unsigned int base = 10;
736
 
737
            switch (uc) {
1888 jermar 738
            /*
4180 decky 739
             * String and character conversions.
740
             */
1888 jermar 741
            case 's':
4180 decky 742
                if (qualifier == PrintfQualifierLong)
4210 svoboda 743
                    retval = print_wstr(va_arg(ap, wchar_t *), width, precision, flags, ps);
4180 decky 744
                else
4210 svoboda 745
                    retval = print_str(va_arg(ap, char *), width, precision, flags, ps);
4180 decky 746
 
747
                if (retval < 0) {
1888 jermar 748
                    counter = -counter;
749
                    goto out;
4180 decky 750
                }
751
 
1888 jermar 752
                counter += retval;
4199 svoboda 753
                j = nxt;
1888 jermar 754
                goto next_char;
755
            case 'c':
4180 decky 756
                if (qualifier == PrintfQualifierLong)
757
                    retval = print_wchar(va_arg(ap, wchar_t), width, flags, ps);
758
                else
759
                    retval = print_char(va_arg(ap, unsigned int), width, flags, ps);
760
 
2572 jermar 761
                if (retval < 0) {
1888 jermar 762
                    counter = -counter;
763
                    goto out;
764
                };
4180 decky 765
 
1888 jermar 766
                counter += retval;
4199 svoboda 767
                j = nxt;
1888 jermar 768
                goto next_char;
4180 decky 769
 
770
            /*
1888 jermar 771
             * Integer values
772
             */
4180 decky 773
            case 'P':
774
                /* Pointer */
3058 decky 775
                flags |= __PRINTF_FLAG_BIGCHARS;
1888 jermar 776
            case 'p':
777
                flags |= __PRINTF_FLAG_PREFIX;
778
                base = 16;
779
                qualifier = PrintfQualifierPointer;
4180 decky 780
                break;
781
            case 'b':
1888 jermar 782
                base = 2;
783
                break;
784
            case 'o':
785
                base = 8;
786
                break;
787
            case 'd':
788
            case 'i':
4180 decky 789
                flags |= __PRINTF_FLAG_SIGNED;
1888 jermar 790
            case 'u':
791
                break;
792
            case 'X':
793
                flags |= __PRINTF_FLAG_BIGCHARS;
794
            case 'x':
795
                base = 16;
796
                break;
4180 decky 797
 
798
            /* Percentile itself */
799
            case '%':
1888 jermar 800
                j = i;
801
                goto next_char;
4180 decky 802
 
1888 jermar 803
            /*
804
             * Bad formatting.
805
             */
806
            default:
2572 jermar 807
                /*
808
                 * Unknown format. Now, j is the index of '%'
809
                 * so we will print whole bad format sequence.
1888 jermar 810
                 */
4180 decky 811
                goto next_char;
1271 cejka 812
            }
4180 decky 813
 
814
            /* Print integers */
815
            size_t size;
816
            uint64_t number;
1271 cejka 817
            switch (qualifier) {
1888 jermar 818
            case PrintfQualifierByte:
819
                size = sizeof(unsigned char);
3058 decky 820
                number = (uint64_t) va_arg(ap, unsigned int);
1888 jermar 821
                break;
822
            case PrintfQualifierShort:
823
                size = sizeof(unsigned short);
3058 decky 824
                number = (uint64_t) va_arg(ap, unsigned int);
1888 jermar 825
                break;
826
            case PrintfQualifierInt:
827
                size = sizeof(unsigned int);
3058 decky 828
                number = (uint64_t) va_arg(ap, unsigned int);
1888 jermar 829
                break;
830
            case PrintfQualifierLong:
831
                size = sizeof(unsigned long);
3058 decky 832
                number = (uint64_t) va_arg(ap, unsigned long);
1888 jermar 833
                break;
834
            case PrintfQualifierLongLong:
835
                size = sizeof(unsigned long long);
3058 decky 836
                number = (uint64_t) va_arg(ap, unsigned long long);
1888 jermar 837
                break;
838
            case PrintfQualifierPointer:
839
                size = sizeof(void *);
3058 decky 840
                number = (uint64_t) (unsigned long) va_arg(ap, void *);
1888 jermar 841
                break;
4180 decky 842
            default:
843
                /* Unknown qualifier */
1888 jermar 844
                counter = -counter;
845
                goto out;
1271 cejka 846
            }
847
 
848
            if (flags & __PRINTF_FLAG_SIGNED) {
2572 jermar 849
                if (number & (0x1 << (size * 8 - 1))) {
1271 cejka 850
                    flags |= __PRINTF_FLAG_NEGATIVE;
4180 decky 851
 
1780 jermar 852
                    if (size == sizeof(uint64_t)) {
3058 decky 853
                        number = -((int64_t) number);
1271 cejka 854
                    } else {
855
                        number = ~number;
2572 jermar 856
                        number &=
857
                            ~(0xFFFFFFFFFFFFFFFFll <<
858
                            (size * 8));
1271 cejka 859
                        number++;
860
                    }
861
                }
862
            }
4180 decky 863
 
2572 jermar 864
            if ((retval = print_number(number, width, precision,
865
                base, flags, ps)) < 0) {
1271 cejka 866
                counter = -counter;
867
                goto out;
2572 jermar 868
            }
4180 decky 869
 
1271 cejka 870
            counter += retval;
4199 svoboda 871
            j = nxt;
4180 decky 872
        }
1271 cejka 873
next_char:
4199 svoboda 874
        ;
1271 cejka 875
    }
876
 
877
    if (i > j) {
4213 decky 878
        if ((retval = printf_putnchars(&fmt[j], i - j, ps)) < 0) {
4180 decky 879
            /* Error */
1271 cejka 880
            counter = -counter;
881
            goto out;
882
        }
883
        counter += retval;
884
    }
4180 decky 885
 
1271 cejka 886
out:
4180 decky 887
    return ((int) counter);
1271 cejka 888
}
889
 
1888 jermar 890
/** @}
1702 cejka 891
 */