Subversion Repositories HelenOS

Rev

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

Rev Author Line No. Line
1018 decky 1
/*
2071 jermar 2
 * Copyright (c) 2006 Martin Decky
1018 decky 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
 
2465 jermar 29
/** @addtogroup generic
30
 * @{
31
 */
32
/** @file
33
 */
34
 
1018 decky 35
#include "printf.h"
1763 jermar 36
#include "stdarg.h"
37
#include <types.h>
1018 decky 38
 
1763 jermar 39
typedef char *char_ptr;
40
 
1018 decky 41
static char digits[] = "0123456789abcdef";  /**< Hexadecimal characters */
42
 
43
void puts(const char *str)
44
{
45
    int len = 0;
46
 
47
    while (str[len] != 0)
48
        len++;
49
 
50
    write(str, len);
51
}
52
 
53
 
54
/** Print hexadecimal digits
55
 *
56
 * Print fixed count of hexadecimal digits from
57
 * the number num. The digits are printed in
58
 * natural left-to-right order starting with
59
 * the width-th digit.
60
 *
61
 * @param num   Number containing digits.
62
 * @param width Count of digits to print.
63
 *
64
 */
1779 jermar 65
static void print_fixed_hex(const uint64_t num, const int width)
1018 decky 66
{
67
    int i;
68
 
69
    for (i = width * 8 - 4; i >= 0; i -= 4)
70
        write(digits + ((num >> i) & 0xf), 1);
71
}
72
 
73
 
74
/** Print number in given base
75
 *
76
 * Print significant digits of a number in given
77
 * base.
78
 *
79
 * @param num  Number to print.
80
 * @param base Base to print the number in (should
81
 *             be in range 2 .. 16).
82
 *
83
 */
1779 jermar 84
static void print_number(const unative_t num, const unsigned int base)
1018 decky 85
{
86
    int val = num;
1779 jermar 87
    char d[sizeof(unative_t) * 8 + 1];      /* this is good enough even for base == 2 */
88
    int i = sizeof(unative_t) * 8 - 1;
1018 decky 89
 
90
    do {
91
        d[i--] = digits[val % base];
92
    } while (val /= base);
93
 
1779 jermar 94
    d[sizeof(unative_t) * 8] = 0;  
1018 decky 95
    puts(&d[i + 1]);
96
}
97
 
98
 
99
/** General formatted text print
100
 *
101
 * Print text formatted according the fmt parameter
102
 * and variant arguments. Each formatting directive
103
 * begins with \% (percentage) character and one of the
104
 * following character:
105
 *
106
 * \%    Prints the percentage character.
107
 *
108
 * s    The next variant argument is treated as char*
109
 *      and printed as a NULL terminated string.
110
 *
111
 * c    The next variant argument is treated as a single char.
112
 *
113
 * p    The next variant argument is treated as a maximum
114
 *      bit-width integer with respect to architecture
115
 *      and printed in full hexadecimal width.
116
 *
117
 * P    As with 'p', but '0x' is prefixed.
118
 *
119
 * q    The next variant argument is treated as a 64b integer
120
 *      and printed in full hexadecimal width.
121
 *
122
 * Q    As with 'q', but '0x' is prefixed.
123
 *
124
 * l    The next variant argument is treated as a 32b integer
125
 *      and printed in full hexadecimal width.
126
 *
127
 * L    As with 'l', but '0x' is prefixed.
128
 *
129
 * w    The next variant argument is treated as a 16b integer
130
 *      and printed in full hexadecimal width.
131
 *
132
 * W    As with 'w', but '0x' is prefixed.
133
 *
134
 * b    The next variant argument is treated as a 8b integer
135
 *      and printed in full hexadecimal width.
136
 *
137
 * B    As with 'b', but '0x' is prefixed.
138
 *
139
 * d    The next variant argument is treated as integer
140
 *      and printed in standard decimal format (only significant
141
 *      digits).
142
 *
143
 * x    The next variant argument is treated as integer
144
 *      and printed in standard hexadecimal format (only significant
145
 *      digits).
146
 *
147
 * X    As with 'x', but '0x' is prefixed.
148
 *
149
 * All other characters from fmt except the formatting directives
150
 * are printed in verbatim.
151
 *
152
 * @param fmt Formatting NULL terminated string.
153
 */
154
void printf(const char *fmt, ...)
155
{
156
    int i = 0;
157
    va_list ap;
158
    char c;
159
 
160
    va_start(ap, fmt);
161
 
162
    while ((c = fmt[i++])) {
163
        switch (c) {
164
 
165
            /* control character */
166
            case '%':
167
 
168
                switch (c = fmt[i++]) {
169
 
170
                    /* percentile itself */
171
                    case '%':
172
                        break;
173
 
174
                    /*
175
                     * String and character conversions.
176
                     */
177
                    case 's':
178
                        puts(va_arg(ap, char_ptr));
179
                        goto loop;
180
 
181
                    case 'c':
182
                        c = (char) va_arg(ap, int);
183
                        break;
184
 
185
                    /*
186
                     * Hexadecimal conversions with fixed width.
187
                     */
188
                    case 'P':
189
                        puts("0x");
190
                    case 'p':
1779 jermar 191
                        print_fixed_hex(va_arg(ap, unative_t), sizeof(unative_t));
1018 decky 192
                        goto loop;
193
 
194
                    case 'Q':
195
                        puts("0x");
196
                    case 'q':
1779 jermar 197
                        print_fixed_hex(va_arg(ap, uint64_t), INT64);
1018 decky 198
                        goto loop;
199
 
200
                    case 'L':
201
                        puts("0x");
202
                    case 'l':
1779 jermar 203
                        print_fixed_hex(va_arg(ap, unative_t), INT32);
1018 decky 204
                        goto loop;
205
 
206
                    case 'W':
207
                        puts("0x");
208
                    case 'w':
1779 jermar 209
                        print_fixed_hex(va_arg(ap, unative_t), INT16);
1018 decky 210
                        goto loop;
211
 
212
                    case 'B':
213
                        puts("0x");
214
                    case 'b':
1779 jermar 215
                        print_fixed_hex(va_arg(ap, unative_t), INT8);
1018 decky 216
                        goto loop;
217
 
218
                    /*
219
                     * Decimal and hexadecimal conversions.
220
                     */
221
                    case 'd':
1779 jermar 222
                        print_number(va_arg(ap, unative_t), 10);
1018 decky 223
                        goto loop;
224
 
225
                    case 'X':
226
                        puts("0x");
227
                    case 'x':
1779 jermar 228
                        print_number(va_arg(ap, unative_t), 16);
1018 decky 229
                        goto loop;
230
 
231
                    /*
232
                     * Bad formatting.
233
                     */
234
                    default:
235
                        goto out;
236
            }
237
 
238
            default:
239
                write(&c, 1);
240
        }
241
 
242
loop:
243
        ;
244
    }
245
 
246
out:
247
 
248
    va_end(ap);
249
}
2465 jermar 250
 
251
/** @}
252
 */