Subversion Repositories HelenOS

Rev

Rev 4055 | Go to most recent revision | Show entire file | Regard whitespace | Details | Blame | Last modification | View Log | RSS feed

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