Subversion Repositories HelenOS

Rev

Rev 1962 | Details | Compare with Previous | Last modification | View Log | RSS feed

Rev Author Line No. Line
1 jermar 1
/*
2
 * Copyright (C) 2001-2004 Jakub Jermar
3
 * All rights reserved.
4
 *
5
 * Redistribution and use in source and binary forms, with or without
6
 * modification, are permitted provided that the following conditions
7
 * are met:
8
 *
9
 * - Redistributions of source code must retain the above copyright
10
 *   notice, this list of conditions and the following disclaimer.
11
 * - Redistributions in binary form must reproduce the above copyright
12
 *   notice, this list of conditions and the following disclaimer in the
13
 *   documentation and/or other materials provided with the distribution.
14
 * - The name of the author may not be used to endorse or promote products
15
 *   derived from this software without specific prior written permission.
16
 *
17
 * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR
18
 * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
19
 * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
20
 * IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT,
21
 * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
22
 * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
23
 * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
24
 * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
25
 * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
26
 * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
27
 */
28
 
29
#include <putchar.h>
30
#include <print.h>
31
#include <synch/spinlock.h>
40 jermar 32
#include <arch/arg.h>
115 jermar 33
#include <arch/asm.h>
228 cejka 34
#include <arch/fmath.h>
35
 
195 vana 36
#include <arch.h>
1 jermar 37
 
61 decky 38
static char digits[] = "0123456789abcdef"; /**< Hexadecimal characters */
39
static spinlock_t printflock;              /**< printf spinlock */
1 jermar 40
 
228 cejka 41
#define DEFAULT_DOUBLE_PRECISION 16
42
#define DEFAULT_DOUBLE_BUFFER_SIZE 128
61 decky 43
 
452 decky 44
 
45
/** Print NULL terminated string
46
 *
47
 * Print characters from str using putchar() until
48
 * \\0 character is reached.
49
 *
50
 * @param str Characters to print.
51
 *
52
 */
53
static void print_str(const char *str)
228 cejka 54
{
452 decky 55
    int i = 0;
56
    char c;
57
 
58
    while (c = str[i++])
59
        putchar(c);
60
}
61
 
62
 
63
/** Print hexadecimal digits
64
 *
65
 * Print fixed count of hexadecimal digits from
66
 * the number num. The digits are printed in
67
 * natural left-to-right order starting with
68
 * the width-th digit.
69
 *
70
 * @param num   Number containing digits.
71
 * @param width Count of digits to print.
72
 *
73
 */
74
static void print_fixed_hex(const __u64 num, const int width)
75
{
76
    int i;
77
 
78
    for (i = width*8 - 4; i >= 0; i -= 4)
79
        putchar(digits[(num>>i) & 0xf]);
80
}
81
 
82
 
83
/** Print number in given base
84
 *
85
 * Print significant digits of a number in given
86
 * base.
87
 *
88
 * @param num  Number to print.
89
 * @param base Base to print the number in (should
90
 *             be in range 2 .. 16).
91
 *
92
 */
93
static void print_number(const __native num, const unsigned int base)
94
{
95
    int val = num;
96
    char d[sizeof(__native)*8+1];       /* this is good enough even for base == 2 */
97
    int i = sizeof(__native)*8-1;
98
 
99
    do {
100
        d[i--] = digits[val % base];
101
    } while (val /= base);
102
 
103
    d[sizeof(__native)*8] = 0; 
104
    print_str(&d[i + 1]);
105
}
106
 
107
 
108
static void print_double(double num, __u8 modifier, __u16 precision)
109
{
228 cejka 110
    double intval,intval2;
111
    int counter;
112
    int exponent,exponenttmp;
113
    unsigned char buf[DEFAULT_DOUBLE_BUFFER_SIZE];
114
    unsigned long in1,in2; 
264 cejka 115
 
266 cejka 116
 
228 cejka 117
    if (fmath_is_nan(num)) {
118
        print_str("NaN");
119
        return;
120
    }
121
 
266 cejka 122
    if (num<0.0) {
228 cejka 123
        putchar('-');
266 cejka 124
        num=num*-1.0;
323 jermar 125
    }
228 cejka 126
 
266 cejka 127
 
128
    if (fmath_is_infinity(num)) {
129
        print_str("Inf");
130
        return;
323 jermar 131
    }
266 cejka 132
 
264 cejka 133
    if ((modifier=='E')||(modifier=='e')) {
134
        intval2=fmath_fint(fmath_get_decimal_exponent(num),&intval);
135
        exponent=intval;
276 cejka 136
        if ((intval2<0.0)) exponent--;
264 cejka 137
        num = num / ((fmath_dpow(10.0,exponent)));
138
 
323 jermar 139
        print_double(num,modifier+1,precision); /* modifier+1 = E => F or e => f */
264 cejka 140
        putchar(modifier);
141
        if (exponent<0) {
142
            putchar('-');
143
            exponent*=-1;
323 jermar 144
        }
264 cejka 145
        print_number(exponent,10);
146
        return;
323 jermar 147
    }
264 cejka 148
 
323 jermar 149
    /* TODO: rounding constant - when we got fraction >= 0.5, we must increment last printed number */
228 cejka 150
 
323 jermar 151
    /*
152
     * Here is a problem with cumulative error while printing big double values -> we will divide
153
     * the number with a power of 10, print new number with better method for small numbers and
154
     * then print decimal point at correct position.
155
     */
228 cejka 156
 
157
    fmath_fint(fmath_get_decimal_exponent(num),&intval);
158
 
159
    exponent=(intval>0.0?intval:0);
160
 
161
    precision+=exponent;
162
 
163
    if (exponent>0) num = num / ((fmath_dpow(10.0,exponent)));
164
 
165
    num=fmath_fint(num,&intval);
166
 
167
    if (precision>0) {
168
        counter=precision-1;
169
        if (exponent>0) counter++;
170
 
171
        if (counter>=DEFAULT_DOUBLE_BUFFER_SIZE) {
172
            counter=DEFAULT_DOUBLE_BUFFER_SIZE;
173
        }
174
        exponenttmp=exponent;
175
        while(counter>=0) {
176
            num *= 10.0;
177
            num = fmath_fint(num,&intval2);
178
            buf[counter--]=((int)intval2)+'0';
179
            exponenttmp--;
180
            if ((exponenttmp==0)&&(counter>=0)) buf[counter--]='.';
181
        }
182
        counter=precision;
183
        if ((exponent==0)&&(counter<DEFAULT_DOUBLE_BUFFER_SIZE)) buf[counter]='.';
184
        counter++; 
185
    } else {
186
        counter=0; 
187
    }
188
 
276 cejka 189
    in1=intval;
190
    if (in1==0.0) {
228 cejka 191
        if (counter<DEFAULT_DOUBLE_BUFFER_SIZE) buf[counter++]='0';
192
    } else {
193
        while(( in1>0 )&&(counter<DEFAULT_DOUBLE_BUFFER_SIZE)) {
194
 
195
            in2=in1;
196
            in1/=10;
197
            buf[counter]=in2-in1*10 + '0';
198
            counter++;
199
        }
200
    }
201
 
202
    counter = (counter>=DEFAULT_DOUBLE_BUFFER_SIZE?DEFAULT_DOUBLE_BUFFER_SIZE:counter);
203
    while (counter>0) {
204
        putchar(buf[--counter]);
323 jermar 205
    }
228 cejka 206
    return;
207
}
208
 
1 jermar 209
 
61 decky 210
/** General formatted text print
211
 *
212
 * Print text formatted according the fmt parameter
213
 * and variant arguments. Each formatting directive
405 jermar 214
 * begins with \% (percentage) character and one of the
61 decky 215
 * following character:
216
 *
405 jermar 217
 * \%    Prints the percentage character.
218
 *
66 jermar 219
 * s    The next variant argument is treated as char*
61 decky 220
 *      and printed as a NULL terminated string.
405 jermar 221
 *
66 jermar 222
 * c    The next variant argument is treated as a single char.
405 jermar 223
 *
77 jermar 224
 * p    The next variant argument is treated as a maximum
225
 *      bit-width integer with respect to architecture
226
 *      and printed in full hexadecimal width.
405 jermar 227
 *
77 jermar 228
 * P    As with 'p', but '0x' is prefixed.
405 jermar 229
 *
77 jermar 230
 * q    The next variant argument is treated as a 64b integer
231
 *      and printed in full hexadecimal width.
405 jermar 232
 *
77 jermar 233
 * Q    As with 'q', but '0x' is prefixed.
405 jermar 234
 *
66 jermar 235
 * l    The next variant argument is treated as a 32b integer
61 decky 236
 *      and printed in full hexadecimal width.
405 jermar 237
 *
61 decky 238
 * L    As with 'l', but '0x' is prefixed.
405 jermar 239
 *
66 jermar 240
 * w    The next variant argument is treated as a 16b integer
61 decky 241
 *      and printed in full hexadecimal width.
405 jermar 242
 *
61 decky 243
 * W    As with 'w', but '0x' is prefixed.
405 jermar 244
 *
66 jermar 245
 * b    The next variant argument is treated as a 8b integer
61 decky 246
 *      and printed in full hexadecimal width.
405 jermar 247
 *
248
 * B    As with 'b', but '0x' is prefixed.
249
 *
66 jermar 250
 * d    The next variant argument is treated as integer
61 decky 251
 *      and printed in standard decimal format (only significant
252
 *      digits).
405 jermar 253
 *
66 jermar 254
 * x    The next variant argument is treated as integer
61 decky 255
 *      and printed in standard hexadecimal format (only significant
256
 *      digits).
405 jermar 257
 *
61 decky 258
 * X    As with 'x', but '0x' is prefixed.
405 jermar 259
 *
323 jermar 260
 * .    The decimal number following period will be treated as precision
261
 *      for printing floating point numbers. One of 'e', 'E', 'f' or 'F'
262
 *      must follow.
405 jermar 263
 *
323 jermar 264
 * e    The next variant argument is treated as double precision float
265
 *      and printed in exponent notation with only one digit before decimal point
266
 *      in specified precision. The exponent sign is printed as 'e'.
405 jermar 267
 *
323 jermar 268
 * E    As with 'e', but the exponent sign is printed as 'E'.
405 jermar 269
 *
323 jermar 270
 * f    The next variant argument is treated as double precision float
271
 *      and printed in decimal notation in specified precision.
405 jermar 272
 *
323 jermar 273
 * F    As with 'f'.
61 decky 274
 *
275
 * All other characters from fmt except the formatting directives
276
 * are printed in verbatim.
277
 *
278
 * @param fmt Formatting NULL terminated string.
1 jermar 279
 */
63 decky 280
void printf(const char *fmt, ...)
1 jermar 281
{
40 jermar 282
    int irqpri, i = 0;
283
    va_list ap;
284
    char c;
264 cejka 285
 
286
    __u16 precision;
287
 
40 jermar 288
    va_start(ap, fmt);
289
 
413 jermar 290
    irqpri = interrupts_disable();
1 jermar 291
    spinlock_lock(&printflock);
40 jermar 292
 
1 jermar 293
    while (c = fmt[i++]) {
294
        switch (c) {
295
 
296
            /* control character */
297
            case '%':
323 jermar 298
            precision = DEFAULT_DOUBLE_PRECISION;
299
            if (fmt[i]=='.') {
300
                precision=0;
301
                c=fmt[++i];
302
                while((c>='0')&&(c<='9')) {
303
                    precision = precision*10 + c - '0';
264 cejka 304
                    c=fmt[++i];
305
                }
323 jermar 306
            }
264 cejka 307
 
323 jermar 308
            switch (c = fmt[i++]) {
1 jermar 309
 
323 jermar 310
                /* percentile itself */
311
                case '%':
312
                break;
1 jermar 313
 
323 jermar 314
                /*
315
                 * String and character conversions.
316
                 */
317
                case 's':
318
                print_str(va_arg(ap, char_ptr));
319
                goto loop;
1 jermar 320
 
323 jermar 321
                case 'c':
322
                c = (char) va_arg(ap, int);
323
                break;
1 jermar 324
 
323 jermar 325
                /*
326
                     * Hexadecimal conversions with fixed width.
327
                     */
328
                case 'P':
329
                print_str("0x");
330
                case 'p':
331
                    print_fixed_hex(va_arg(ap, __native), sizeof(__native));
332
                goto loop;
77 jermar 333
 
323 jermar 334
                case 'Q':
335
                print_str("0x");
336
                case 'q':
337
                    print_fixed_hex(va_arg(ap, __u64), INT64);
338
                goto loop;
77 jermar 339
 
323 jermar 340
                case 'L':
341
                print_str("0x");
342
                case 'l':
343
                    print_fixed_hex(va_arg(ap, __native), INT32);
344
                goto loop;
1 jermar 345
 
323 jermar 346
                case 'W':
347
                print_str("0x");
348
                case 'w':
349
                    print_fixed_hex(va_arg(ap, __native), INT16);
350
                goto loop;
1 jermar 351
 
323 jermar 352
                case 'B':
353
                print_str("0x");
354
                case 'b':
355
                    print_fixed_hex(va_arg(ap, __native), INT8);
356
                goto loop;
1 jermar 357
 
323 jermar 358
                /*
359
                     * Floating point conversions.
360
                     */
361
                case 'F':
362
                    print_double(va_arg(ap, double),'F',precision);
363
                goto loop;
264 cejka 364
 
323 jermar 365
                case 'f':
366
                    print_double(va_arg(ap, double),'f',precision);
367
                goto loop;
264 cejka 368
 
323 jermar 369
                case 'E':
370
                    print_double(va_arg(ap, double),'E',precision);
371
                goto loop;
372
                case 'e':
373
                    print_double(va_arg(ap, double),'e',precision);
374
                goto loop;
264 cejka 375
 
323 jermar 376
                /*
377
                     * Decimal and hexadecimal conversions.
378
                     */
379
                case 'd':
380
                    print_number(va_arg(ap, __native), 10);
381
                goto loop;
1 jermar 382
 
323 jermar 383
                case 'X':
384
                print_str("0x");
385
                case 'x':
386
                    print_number(va_arg(ap, __native), 16);
387
                goto loop;
1 jermar 388
 
323 jermar 389
                /*
390
                 * Bad formatting.
391
                 */
392
                default:
393
                goto out;
394
            }
1 jermar 395
 
396
            default: putchar(c);
397
        }
398
 
399
loop:
400
        ;
401
    }
402
 
403
out:
404
    spinlock_unlock(&printflock);
413 jermar 405
    interrupts_restore(irqpri);
40 jermar 406
 
407
    va_end(ap);
1 jermar 408
}