source: mainline/src/debug/print.c@ dd80fc6

lfn serial ticket/834-toolchain-update topic/msim-upgrade topic/simplify-dev-export
Last change on this file since dd80fc6 was c835e7c, checked in by Josef Cejka <malyzelenyhnus@…>, 20 years ago

Printf "E" and "F" format fixed.
  • Property mode set to 100644
File size: 9.3 KB
RevLine 
[f761f1eb]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>
[0d2f805]32#include <arch/arg.h>
[18e0a6c]33#include <arch/asm.h>
[e83a9f7]34#include <arch/fmath.h>
[0d2f805]35
[e83a9f7]36#include <arch.h>
[f761f1eb]37
[724b58a]38static char digits[] = "0123456789abcdef"; /**< Hexadecimal characters */
39static spinlock_t printflock; /**< printf spinlock */
[f761f1eb]40
[e83a9f7]41#define DEFAULT_DOUBLE_PRECISION 16
42#define DEFAULT_DOUBLE_BUFFER_SIZE 128
43
[51022e9b]44void print_double(double num, __u8 modifier, __u16 precision)
[e83a9f7]45{
46 double intval,intval2;
47 int counter;
48 int exponent,exponenttmp;
49 unsigned char buf[DEFAULT_DOUBLE_BUFFER_SIZE];
50 unsigned long in1,in2;
[51022e9b]51
[2f08a55d]52
[e83a9f7]53 if (fmath_is_nan(num)) {
54 print_str("NaN");
55 return;
56 }
57
[2f08a55d]58 if (num<0.0) {
[e83a9f7]59 putchar('-');
[2f08a55d]60 num=num*-1.0;
61 }
62
63
64 if (fmath_is_infinity(num)) {
65 print_str("Inf");
66 return;
[e83a9f7]67 }
68
[51022e9b]69 if ((modifier=='E')||(modifier=='e')) {
70 intval2=fmath_fint(fmath_get_decimal_exponent(num),&intval);
71 exponent=intval;
[c835e7c]72 if ((intval2<0.0)) exponent--;
[51022e9b]73 num = num / ((fmath_dpow(10.0,exponent)));
74
75 print_double(num,modifier+1,precision); //modifier+1 = E => F or e => f
76 putchar(modifier);
77 if (exponent<0) {
78 putchar('-');
79 exponent*=-1;
80 }
81 print_number(exponent,10);
82 return;
83 }
84
[e83a9f7]85 //TODO: rounding constant - when we got fraction >= 0.5, we must increment last printed number
86
87 /* Here is problem with cumulative error while printing big double values -> we will divide
88 the number with a power of 10, print new number with better method for small numbers and then print decimal point at correct position */
89
90 fmath_fint(fmath_get_decimal_exponent(num),&intval);
91
92 exponent=(intval>0.0?intval:0);
93
94 precision+=exponent;
95
96 if (exponent>0) num = num / ((fmath_dpow(10.0,exponent)));
97
98 num=fmath_fint(num,&intval);
99
100 if (precision>0) {
101 counter=precision-1;
102 if (exponent>0) counter++;
103
104 if (counter>=DEFAULT_DOUBLE_BUFFER_SIZE) {
105 counter=DEFAULT_DOUBLE_BUFFER_SIZE;
106 }
107 exponenttmp=exponent;
108 while(counter>=0) {
109 num *= 10.0;
110 num = fmath_fint(num,&intval2);
111 buf[counter--]=((int)intval2)+'0';
112 exponenttmp--;
113 if ((exponenttmp==0)&&(counter>=0)) buf[counter--]='.';
114 }
115 counter=precision;
116 if ((exponent==0)&&(counter<DEFAULT_DOUBLE_BUFFER_SIZE)) buf[counter]='.';
117 counter++;
118 } else {
119 counter=0;
120 }
121
[c835e7c]122 in1=intval;
123 if (in1==0.0) {
[e83a9f7]124 if (counter<DEFAULT_DOUBLE_BUFFER_SIZE) buf[counter++]='0';
125 } else {
126 while(( in1>0 )&&(counter<DEFAULT_DOUBLE_BUFFER_SIZE)) {
127
128 in2=in1;
129 in1/=10;
130 buf[counter]=in2-in1*10 + '0';
131 counter++;
132 }
133 }
134
135 counter = (counter>=DEFAULT_DOUBLE_BUFFER_SIZE?DEFAULT_DOUBLE_BUFFER_SIZE:counter);
136 while (counter>0) {
137 putchar(buf[--counter]);
138 };
139 return;
140}
[724b58a]141
142/** Print NULL terminated string
143 *
144 * Print characters from str using putchar() until
145 * \x00 character is reached.
146 *
147 * @param str Characters to print.
148 *
149 */
[27dc170]150void print_str(const char *str)
[f761f1eb]151{
[02a99d2]152 int i = 0;
[f761f1eb]153 char c;
[02a99d2]154
[f761f1eb]155 while (c = str[i++])
[02a99d2]156 putchar(c);
[f761f1eb]157}
158
159
[724b58a]160/** Print hexadecimal digits
161 *
162 * Print fixed count of hexadecimal digits from
163 * the number num. The digits are printed in
164 * natural left-to-right order starting with
165 * the width-th digit.
166 *
167 * @param num Number containing digits.
168 * @param width Count of digits to print.
169 *
[f761f1eb]170 */
[81887b7]171void print_fixed_hex(const __u64 num, const int width)
[f761f1eb]172{
173 int i;
174
175 for (i = width*8 - 4; i >= 0; i -= 4)
176 putchar(digits[(num>>i) & 0xf]);
177}
178
[724b58a]179
180/** Print number in given base
181 *
182 * Print significant digits of a number in given
183 * base.
184 *
185 * @param num Number to print.
186 * @param base Base to print the number in (should
187 * be in range 2 .. 16).
188 *
[f761f1eb]189 */
[02a99d2]190void print_number(const __native num, const unsigned int base)
[27dc170]191{
192 int val = num;
[199145a1]193 char d[sizeof(__native)*8+1]; /* this is good enough even for base == 2 */
[02a99d2]194 int i = sizeof(__native)*8-1;
195
[f761f1eb]196 do {
[27dc170]197 d[i--] = digits[val % base];
198 } while (val /= base);
[f761f1eb]199
[199145a1]200 d[sizeof(__native)*8] = 0;
[f761f1eb]201 print_str(&d[i + 1]);
202}
203
[724b58a]204
205/** General formatted text print
206 *
207 * Print text formatted according the fmt parameter
208 * and variant arguments. Each formatting directive
209 * begins with % (percentage) character and one of the
210 * following character:
211 *
212 * % Prints the percentage character.
[d7568a9f]213 * s The next variant argument is treated as char*
[724b58a]214 * and printed as a NULL terminated string.
[d7568a9f]215 * c The next variant argument is treated as a single char.
[da79d0fd]216 * p The next variant argument is treated as a maximum
217 * bit-width integer with respect to architecture
218 * and printed in full hexadecimal width.
219 * P As with 'p', but '0x' is prefixed.
220 * q The next variant argument is treated as a 64b integer
221 * and printed in full hexadecimal width.
222 * Q As with 'q', but '0x' is prefixed.
[d7568a9f]223 * l The next variant argument is treated as a 32b integer
[724b58a]224 * and printed in full hexadecimal width.
225 * L As with 'l', but '0x' is prefixed.
[d7568a9f]226 * w The next variant argument is treated as a 16b integer
[724b58a]227 * and printed in full hexadecimal width.
228 * W As with 'w', but '0x' is prefixed.
[d7568a9f]229 * b The next variant argument is treated as a 8b integer
[724b58a]230 * and printed in full hexadecimal width.
231 * N As with 'b', but '0x' is prefixed.
[d7568a9f]232 * d The next variant argument is treated as integer
[724b58a]233 * and printed in standard decimal format (only significant
234 * digits).
[d7568a9f]235 * x The next variant argument is treated as integer
[724b58a]236 * and printed in standard hexadecimal format (only significant
237 * digits).
238 * X As with 'x', but '0x' is prefixed.
239 *
240 * All other characters from fmt except the formatting directives
241 * are printed in verbatim.
242 *
243 * @param fmt Formatting NULL terminated string.
244 *
[f761f1eb]245 */
[27dc170]246void printf(const char *fmt, ...)
[f761f1eb]247{
[0d2f805]248 int irqpri, i = 0;
249 va_list ap;
250 char c;
[51022e9b]251
252 __u16 precision;
253
[0d2f805]254 va_start(ap, fmt);
[f761f1eb]255
256 irqpri = cpu_priority_high();
257 spinlock_lock(&printflock);
[0d2f805]258
[f761f1eb]259 while (c = fmt[i++]) {
260 switch (c) {
261
[51022e9b]262
263
[f761f1eb]264 /* control character */
265 case '%':
[51022e9b]266
267 precision = DEFAULT_DOUBLE_PRECISION;
268 if (fmt[i]=='.') {
269 precision=0;
270 c=fmt[++i];
271 while((c>='0')&&(c<='9')) {
272 precision = precision*10 + c - '0';
273 c=fmt[++i];
274 }
275
276 }
277
[f761f1eb]278 switch (c = fmt[i++]) {
279
280 /* percentile itself */
281 case '%':
282 break;
283
284 /*
285 * String and character conversions.
286 */
287 case 's':
[0d2f805]288 print_str(va_arg(ap, char_ptr));
[f761f1eb]289 goto loop;
290
291 case 'c':
[199145a1]292 c = (char) va_arg(ap, int);
[f761f1eb]293 break;
294
295 /*
296 * Hexadecimal conversions with fixed width.
297 */
[da79d0fd]298 case 'P':
299 print_str("0x");
300 case 'p':
301 print_fixed_hex(va_arg(ap, __native), sizeof(__native));
302 goto loop;
303
304 case 'Q':
305 print_str("0x");
306 case 'q':
[81887b7]307 print_fixed_hex(va_arg(ap, __u64), INT64);
[da79d0fd]308 goto loop;
309
[f761f1eb]310 case 'L':
311 print_str("0x");
312 case 'l':
[0d2f805]313 print_fixed_hex(va_arg(ap, __native), INT32);
[f761f1eb]314 goto loop;
315
316 case 'W':
317 print_str("0x");
318 case 'w':
[0d2f805]319 print_fixed_hex(va_arg(ap, __native), INT16);
[f761f1eb]320 goto loop;
321
322 case 'B':
323 print_str("0x");
324 case 'b':
[0d2f805]325 print_fixed_hex(va_arg(ap, __native), INT8);
[f761f1eb]326 goto loop;
327
[e83a9f7]328 /*
329 * Floating point conversions.
330 */
331
332 case 'F':
[51022e9b]333 print_double(va_arg(ap, double),'F',precision);
334 goto loop;
335
[e83a9f7]336 case 'f':
[51022e9b]337 print_double(va_arg(ap, double),'f',precision);
[e83a9f7]338 goto loop;
[51022e9b]339
340 case 'E':
341 print_double(va_arg(ap, double),'E',precision);
342 goto loop;
343 case 'e':
344 print_double(va_arg(ap, double),'e',precision);
345 goto loop;
346
[f761f1eb]347 /*
348 * Decimal and hexadecimal conversions.
349 */
350 case 'd':
[0d2f805]351 print_number(va_arg(ap, __native), 10);
[f761f1eb]352 goto loop;
353
354 case 'X':
355 print_str("0x");
356 case 'x':
[0d2f805]357 print_number(va_arg(ap, __native), 16);
[f761f1eb]358 goto loop;
359
360 /*
361 * Bad formatting.
362 */
363 default:
364 goto out;
365 }
366
367 default: putchar(c);
368 }
369
370loop:
371 ;
372 }
373
374out:
375 spinlock_unlock(&printflock);
376 cpu_priority_restore(irqpri);
[0d2f805]377
378 va_end(ap);
[f761f1eb]379}
Note: See TracBrowser for help on using the repository browser.