source: mainline/kernel/generic/src/printf/printf_core.c@ c55dd58

lfn serial ticket/834-toolchain-update topic/msim-upgrade topic/simplify-dev-export
Last change on this file since c55dd58 was 06e1e95, checked in by Jakub Jermar <jakub@…>, 19 years ago

C99 compliant header guards (hopefully) everywhere in the kernel.
Formatting and indentation changes.
Small improvements in sparc64.
  • Property mode set to 100644
File size: 18.1 KB
Line 
1/*
2 * Copyright (C) 2001-2004 Jakub Jermar
3 * Copyright (C) 2006 Josef Cejka
4 * All rights reserved.
5 *
6 * Redistribution and use in source and binary forms, with or without
7 * modification, are permitted provided that the following conditions
8 * are met:
9 *
10 * - Redistributions of source code must retain the above copyright
11 * notice, this list of conditions and the following disclaimer.
12 * - Redistributions in binary form must reproduce the above copyright
13 * notice, this list of conditions and the following disclaimer in the
14 * documentation and/or other materials provided with the distribution.
15 * - The name of the author may not be used to endorse or promote products
16 * derived from this software without specific prior written permission.
17 *
18 * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR
19 * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
20 * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
21 * IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT,
22 * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
23 * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
24 * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
25 * 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 * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
28 */
29
30/** @addtogroup generic
31 * @{
32 */
33/**
34 * @file
35 * @brief Printing functions.
36 */
37
38#include <printf/printf_core.h>
39#include <putchar.h>
40#include <print.h>
41#include <synch/spinlock.h>
42#include <arch/arg.h>
43#include <arch/asm.h>
44
45#include <arch.h>
46
47SPINLOCK_INITIALIZE(printflock); /**< printf spinlock */
48
49#define __PRINTF_FLAG_PREFIX 0x00000001 /**< show prefixes 0x or 0*/
50#define __PRINTF_FLAG_SIGNED 0x00000002 /**< signed / unsigned number */
51#define __PRINTF_FLAG_ZEROPADDED 0x00000004 /**< print leading zeroes */
52#define __PRINTF_FLAG_LEFTALIGNED 0x00000010 /**< align to left */
53#define __PRINTF_FLAG_SHOWPLUS 0x00000020 /**< always show + sign */
54#define __PRINTF_FLAG_SPACESIGN 0x00000040 /**< print space instead of plus */
55#define __PRINTF_FLAG_BIGCHARS 0x00000080 /**< show big characters */
56#define __PRINTF_FLAG_NEGATIVE 0x00000100 /**< number has - sign */
57
58#define PRINT_NUMBER_BUFFER_SIZE (64+5) /**< Buffer big enought for 64 bit number
59 * printed in base 2, sign, prefix and
60 * 0 to terminate string.. (last one is only for better testing
61 * end of buffer by zero-filling subroutine)*/
62
63/** Enumeration of possible arguments types.
64 */
65typedef enum {
66 PrintfQualifierByte = 0,
67 PrintfQualifierShort,
68 PrintfQualifierInt,
69 PrintfQualifierLong,
70 PrintfQualifierLongLong,
71 PrintfQualifierNative,
72 PrintfQualifierPointer
73} qualifier_t;
74
75static char digits_small[] = "0123456789abcdef"; /**< Small hexadecimal characters */
76static char digits_big[] = "0123456789ABCDEF"; /**< Big hexadecimal characters */
77
78/** Checks c for a digit.
79 * @param c One character.
80 * @return nonzero if c is from interval '0 to '9'.
81 */
82static inline int isdigit(int c)
83{
84 return ((c >= '0' )&&( c <= '9'));
85}
86
87/** Compute length of given zero terminated string.
88 * @param str Pointer to valid string.
89 * @return string length without trailing zero.
90 */
91static unative_t strlen(const char *str)
92{
93 unative_t counter = 0;
94
95 while (str[counter] != 0) {
96 counter++;
97 }
98
99 return counter;
100}
101
102/** Print count chars from buffer without adding newline
103 * @param buf Buffer with size at least count bytes - NULL pointer NOT allowed!
104 * @param count
105 * @param ps output method and its data
106 * @return number of printed characters
107 */
108static int printf_putnchars(const char * buf, size_t count, struct printf_spec *ps)
109{
110 return ps->write((void *)buf, count, ps->data);
111}
112
113/** Print string without added newline
114 * @param str string to print
115 * @param ps write function specification and support data
116 * @return number of printed characters
117 */
118static int printf_putstr(const char * str, struct printf_spec *ps)
119{
120 size_t count;
121
122 if (str == NULL) {
123 return printf_putnchars("(NULL)", 6, ps);
124 }
125
126 count = strlen(str);
127
128 return ps->write((void *) str, count, ps->data);
129}
130
131/** Print one character to output
132 * @param c one character
133 * @param ps output method
134 * @return number of printed characters
135 */
136static int printf_putchar(int c, struct printf_spec *ps)
137{
138 unsigned char ch = c;
139
140 return ps->write((void *) &ch, 1, ps->data);
141}
142
143/** Print one formatted character
144 * @param c character to print
145 * @param width
146 * @param flags
147 * @return number of printed characters, negative value on fail
148 */
149static int print_char(char c, int width, uint64_t flags, struct printf_spec *ps)
150{
151 int counter = 0;
152
153 if (!(flags & __PRINTF_FLAG_LEFTALIGNED)) {
154 while (--width > 0) { /* one space is consumed by character itself hence predecrement */
155 if (printf_putchar(' ', ps) > 0)
156 ++counter;
157 }
158 }
159
160 if (printf_putchar(c, ps) > 0)
161 counter++;
162
163 while (--width > 0) { /* one space is consumed by character itself hence predecrement */
164 if (printf_putchar(' ', ps) > 0)
165 ++counter;
166 }
167
168 return ++counter;
169}
170
171/** Print one string
172 * @param s string
173 * @param width
174 * @param precision
175 * @param flags
176 * @return number of printed characters or negative value on fail
177 */
178
179static int print_string(char *s, int width, int precision, uint64_t flags, struct printf_spec *ps)
180{
181 int counter = 0;
182 size_t size;
183 int retval;
184
185 if (s == NULL) {
186 return printf_putstr("(NULL)", ps);
187 }
188
189 size = strlen(s);
190
191 /* print leading spaces */
192
193 if (precision == 0)
194 precision = size;
195
196 width -= precision;
197
198 if (!(flags & __PRINTF_FLAG_LEFTALIGNED)) {
199 while (width-- > 0) {
200 if (printf_putchar(' ', ps) == 1)
201 counter++;
202 }
203 }
204
205 while (precision > size) {
206 precision--;
207 if (printf_putchar(' ', ps) == 1)
208 ++counter;
209 }
210
211 if ((retval = printf_putnchars(s, precision, ps)) < 0) {
212 return -counter;
213 }
214 counter += retval;
215
216 while (width-- > 0) {
217 if (printf_putchar(' ', ps) == 1)
218 ++counter;
219 }
220
221 return counter;
222}
223
224
225/** Print number in given base
226 *
227 * Print significant digits of a number in given
228 * base.
229 *
230 * @param num Number to print.
231 * @param width
232 * @param precision
233 * @param base Base to print the number in (should
234 * be in range 2 .. 16).
235 * @param flags output modifiers
236 * @return number of written characters or EOF
237 *
238 */
239static int print_number(uint64_t num, int width, int precision, int base , uint64_t flags, struct printf_spec *ps)
240{
241 char *digits = digits_small;
242 char d[PRINT_NUMBER_BUFFER_SIZE]; /* this is good enough even for base == 2, prefix and sign */
243 char *ptr = &d[PRINT_NUMBER_BUFFER_SIZE - 1];
244 int size = 0; /* size of number with all prefixes and signs */
245 int number_size; /* size of plain number */
246 char sgn;
247 int retval;
248 int counter = 0;
249
250 if (flags & __PRINTF_FLAG_BIGCHARS)
251 digits = digits_big;
252
253 *ptr-- = 0; /* Put zero at end of string */
254
255 if (num == 0) {
256 *ptr-- = '0';
257 size++;
258 } else {
259 do {
260 *ptr-- = digits[num % base];
261 size++;
262 } while (num /= base);
263 }
264
265 number_size = size;
266
267 /* Collect sum of all prefixes/signs/... to calculate padding and leading zeroes */
268 if (flags & __PRINTF_FLAG_PREFIX) {
269 switch(base) {
270 case 2: /* Binary formating is not standard, but usefull */
271 size += 2;
272 break;
273 case 8:
274 size++;
275 break;
276 case 16:
277 size += 2;
278 break;
279 }
280 }
281
282 sgn = 0;
283 if (flags & __PRINTF_FLAG_SIGNED) {
284 if (flags & __PRINTF_FLAG_NEGATIVE) {
285 sgn = '-';
286 size++;
287 } else if (flags & __PRINTF_FLAG_SHOWPLUS) {
288 sgn = '+';
289 size++;
290 } else if (flags & __PRINTF_FLAG_SPACESIGN) {
291 sgn = ' ';
292 size++;
293 }
294 }
295
296 if (flags & __PRINTF_FLAG_LEFTALIGNED) {
297 flags &= ~__PRINTF_FLAG_ZEROPADDED;
298 }
299
300 /* if number is leftaligned or precision is specified then zeropadding is ignored */
301 if (flags & __PRINTF_FLAG_ZEROPADDED) {
302 if ((precision == 0) && (width > size)) {
303 precision = width - size + number_size;
304 }
305 }
306
307 /* print leading spaces */
308 if (number_size > precision) /* We must print whole number not only a part */
309 precision = number_size;
310
311 width -= precision + size - number_size;
312
313 if (!(flags & __PRINTF_FLAG_LEFTALIGNED)) {
314 while (width-- > 0) {
315 if (printf_putchar(' ', ps) == 1)
316 counter++;
317 }
318 }
319
320
321 /* print sign */
322 if (sgn) {
323 if (printf_putchar(sgn, ps) == 1)
324 counter++;
325 }
326
327 /* print prefix */
328
329 if (flags & __PRINTF_FLAG_PREFIX) {
330 switch(base) {
331 case 2: /* Binary formating is not standard, but usefull */
332 if (printf_putchar('0', ps) == 1)
333 counter++;
334 if (flags & __PRINTF_FLAG_BIGCHARS) {
335 if (printf_putchar('B', ps) == 1)
336 counter++;
337 } else {
338 if (printf_putchar('b', ps) == 1)
339 counter++;
340 }
341 break;
342 case 8:
343 if (printf_putchar('o', ps) == 1)
344 counter++;
345 break;
346 case 16:
347 if (printf_putchar('0', ps) == 1)
348 counter++;
349 if (flags & __PRINTF_FLAG_BIGCHARS) {
350 if (printf_putchar('X', ps) == 1)
351 counter++;
352 } else {
353 if (printf_putchar('x', ps) == 1)
354 counter++;
355 }
356 break;
357 }
358 }
359
360 /* print leading zeroes */
361 precision -= number_size;
362 while (precision-- > 0) {
363 if (printf_putchar('0', ps) == 1)
364 counter++;
365 }
366
367
368 /* print number itself */
369
370 if ((retval = printf_putstr(++ptr, ps)) > 0) {
371 counter += retval;
372 }
373
374 /* print ending spaces */
375
376 while (width-- > 0) {
377 if (printf_putchar(' ', ps) == 1)
378 counter++;
379 }
380
381 return counter;
382}
383
384
385/** Print formatted string.
386 *
387 * Print string formatted according to the fmt parameter
388 * and variadic arguments. Each formatting directive
389 * must have the following form:
390 *
391 * \% [ FLAGS ] [ WIDTH ] [ .PRECISION ] [ TYPE ] CONVERSION
392 *
393 * FLAGS:@n
394 * - "#" Force to print prefix.
395 * For conversion \%o the prefix is 0, for \%x and \%X prefixes are 0x and 0X
396 * and for conversion \%b the prefix is 0b.
397 *
398 * - "-" Align to left.
399 *
400 * - "+" Print positive sign just as negative.
401 *
402 * - " " If the printed number is positive and "+" flag is not set, print space in
403 * place of sign.
404 *
405 * - "0" Print 0 as padding instead of spaces. Zeroes are placed between sign and the
406 * rest of the number. This flag is ignored if "-" flag is specified.
407 *
408 * WIDTH:@n
409 * - Specify minimal width of printed argument. If it is bigger, width is ignored.
410 * If width is specified with a "*" character instead of number, width is taken from
411 * parameter list. And integer parameter is expected before parameter for processed
412 * conversion specification. If this value is negative its absolute value is taken
413 * and the "-" flag is set.
414 *
415 * PRECISION:@n
416 * - Value precision. For numbers it specifies minimum valid numbers.
417 * Smaller numbers are printed with leading zeroes. Bigger numbers are not affected.
418 * Strings with more than precision characters are cut off.
419 * Just as with width, an "*" can be used used instead of a number.
420 * An integer value is then expected in parameters. When both width and precision
421 * are specified using "*", the first parameter is used for width and the second one
422 * for precision.
423 *
424 * TYPE:@n
425 * - "hh" Signed or unsigned char.@n
426 * - "h" Signed or usigned short.@n
427 * - "" Signed or usigned int (default value).@n
428 * - "l" Signed or usigned long int.@n
429 * - "ll" Signed or usigned long long int.@n
430 * - "z" unative_t (non-standard extension).@n
431 *
432 *
433 * CONVERSION:@n
434 * - % Print percentile character itself.
435 *
436 * - c Print single character.
437 *
438 * - s Print zero terminated string. If a NULL value is passed as value, "(NULL)" is printed instead.
439 *
440 * - P, p Print value of a pointer. Void * value is expected and it is printed in hexadecimal notation with prefix
441 * (as with \%#X or \%#x for 32bit or \%#X / \%#x for 64bit long pointers).
442 *
443 * - b Print value as unsigned binary number. Prefix is not printed by default. (Nonstandard extension.)
444 *
445 * - o Print value as unsigned octal number. Prefix is not printed by default.
446 *
447 * - d,i Print signed decimal number. There is no difference between d and i conversion.
448 *
449 * - u Print unsigned decimal number.
450 *
451 * - X, x Print hexadecimal number with upper- or lower-case. Prefix is not printed by default.
452 *
453 * All other characters from fmt except the formatting directives
454 * are printed in verbatim.
455 *
456 * @param fmt Formatting NULL terminated string.
457 * @return Number of printed characters or negative value on failure.
458 */
459int printf_core(const char *fmt, struct printf_spec *ps, va_list ap)
460{
461 int irqpri;
462 int i = 0, j = 0; /**< i is index of currently processed char from fmt, j is index to the first not printed nonformating character */
463 int end;
464 int counter; /**< counter of printed characters */
465 int retval; /**< used to store return values from called functions */
466 char c;
467 qualifier_t qualifier; /* type of argument */
468 int base; /**< base in which will be parameter (numbers only) printed */
469 uint64_t number; /**< argument value */
470 size_t size; /**< byte size of integer parameter */
471 int width, precision;
472 uint64_t flags;
473
474 counter = 0;
475
476 irqpri = interrupts_disable();
477 spinlock_lock(&printflock);
478
479 while ((c = fmt[i])) {
480 /* control character */
481 if (c == '%' ) {
482 /* print common characters if any processed */
483 if (i > j) {
484 if ((retval = printf_putnchars(&fmt[j], (size_t)(i - j), ps)) < 0) { /* error */
485 counter = -counter;
486 goto out;
487 }
488 counter += retval;
489 }
490
491 j = i;
492 /* parse modifiers */
493 flags = 0;
494 end = 0;
495
496 do {
497 ++i;
498 switch (c = fmt[i]) {
499 case '#': flags |= __PRINTF_FLAG_PREFIX; break;
500 case '-': flags |= __PRINTF_FLAG_LEFTALIGNED; break;
501 case '+': flags |= __PRINTF_FLAG_SHOWPLUS; break;
502 case ' ': flags |= __PRINTF_FLAG_SPACESIGN; break;
503 case '0': flags |= __PRINTF_FLAG_ZEROPADDED; break;
504 default: end = 1;
505 };
506
507 } while (end == 0);
508
509 /* width & '*' operator */
510 width = 0;
511 if (isdigit(fmt[i])) {
512 while (isdigit(fmt[i])) {
513 width *= 10;
514 width += fmt[i++] - '0';
515 }
516 } else if (fmt[i] == '*') {
517 /* get width value from argument list*/
518 i++;
519 width = (int)va_arg(ap, int);
520 if (width < 0) {
521 /* negative width means to set '-' flag */
522 width *= -1;
523 flags |= __PRINTF_FLAG_LEFTALIGNED;
524 }
525 }
526
527 /* precision and '*' operator */
528 precision = 0;
529 if (fmt[i] == '.') {
530 ++i;
531 if (isdigit(fmt[i])) {
532 while (isdigit(fmt[i])) {
533 precision *= 10;
534 precision += fmt[i++] - '0';
535 }
536 } else if (fmt[i] == '*') {
537 /* get precision value from argument list*/
538 i++;
539 precision = (int)va_arg(ap, int);
540 if (precision < 0) {
541 /* negative precision means to ignore it */
542 precision = 0;
543 }
544 }
545 }
546
547 switch (fmt[i++]) {
548 /** TODO: unimplemented qualifiers:
549 * t ptrdiff_t - ISO C 99
550 */
551 case 'h': /* char or short */
552 qualifier = PrintfQualifierShort;
553 if (fmt[i] == 'h') {
554 i++;
555 qualifier = PrintfQualifierByte;
556 }
557 break;
558 case 'l': /* long or long long*/
559 qualifier = PrintfQualifierLong;
560 if (fmt[i] == 'l') {
561 i++;
562 qualifier = PrintfQualifierLongLong;
563 }
564 break;
565 case 'z': /* unative_t */
566 qualifier = PrintfQualifierNative;
567 break;
568 default:
569 qualifier = PrintfQualifierInt; /* default type */
570 --i;
571 }
572
573 base = 10;
574
575 switch (c = fmt[i]) {
576
577 /*
578 * String and character conversions.
579 */
580 case 's':
581 if ((retval = print_string(va_arg(ap, char*), width, precision, flags, ps)) < 0) {
582 counter = -counter;
583 goto out;
584 };
585
586 counter += retval;
587 j = i + 1;
588 goto next_char;
589 case 'c':
590 c = va_arg(ap, unsigned int);
591 if ((retval = print_char(c, width, flags, ps)) < 0) {
592 counter = -counter;
593 goto out;
594 };
595
596 counter += retval;
597 j = i + 1;
598 goto next_char;
599
600 /*
601 * Integer values
602 */
603 case 'P': /* pointer */
604 flags |= __PRINTF_FLAG_BIGCHARS;
605 case 'p':
606 flags |= __PRINTF_FLAG_PREFIX;
607 base = 16;
608 qualifier = PrintfQualifierPointer;
609 break;
610 case 'b':
611 base = 2;
612 break;
613 case 'o':
614 base = 8;
615 break;
616 case 'd':
617 case 'i':
618 flags |= __PRINTF_FLAG_SIGNED;
619 case 'u':
620 break;
621 case 'X':
622 flags |= __PRINTF_FLAG_BIGCHARS;
623 case 'x':
624 base = 16;
625 break;
626 /* percentile itself */
627 case '%':
628 j = i;
629 goto next_char;
630 /*
631 * Bad formatting.
632 */
633 default:
634 /* Unknown format
635 * now, j is index of '%' so we will
636 * print whole bad format sequence
637 */
638 goto next_char;
639 }
640
641
642 /* Print integers */
643 /* print number */
644 switch (qualifier) {
645 case PrintfQualifierByte:
646 size = sizeof(unsigned char);
647 number = (uint64_t)va_arg(ap, unsigned int);
648 break;
649 case PrintfQualifierShort:
650 size = sizeof(unsigned short);
651 number = (uint64_t)va_arg(ap, unsigned int);
652 break;
653 case PrintfQualifierInt:
654 size = sizeof(unsigned int);
655 number = (uint64_t)va_arg(ap, unsigned int);
656 break;
657 case PrintfQualifierLong:
658 size = sizeof(unsigned long);
659 number = (uint64_t)va_arg(ap, unsigned long);
660 break;
661 case PrintfQualifierLongLong:
662 size = sizeof(unsigned long long);
663 number = (uint64_t)va_arg(ap, unsigned long long);
664 break;
665 case PrintfQualifierPointer:
666 size = sizeof(void *);
667 number = (uint64_t)(unsigned long)va_arg(ap, void *);
668 break;
669 case PrintfQualifierNative:
670 size = sizeof(unative_t);
671 number = (uint64_t)va_arg(ap, unative_t);
672 break;
673 default: /* Unknown qualifier */
674 counter = -counter;
675 goto out;
676 }
677
678 if (flags & __PRINTF_FLAG_SIGNED) {
679 if (number & (0x1 << (size*8 - 1))) {
680 flags |= __PRINTF_FLAG_NEGATIVE;
681
682 if (size == sizeof(uint64_t)) {
683 number = -((int64_t)number);
684 } else {
685 number = ~number;
686 number &= (~((0xFFFFFFFFFFFFFFFFll) << (size * 8)));
687 number++;
688 }
689 }
690 }
691
692 if ((retval = print_number(number, width, precision, base, flags, ps)) < 0) {
693 counter = -counter;
694 goto out;
695 };
696
697 counter += retval;
698 j = i + 1;
699 }
700next_char:
701
702 ++i;
703 }
704
705 if (i > j) {
706 if ((retval = printf_putnchars(&fmt[j], (unative_t)(i - j), ps)) < 0) { /* error */
707 counter = -counter;
708 goto out;
709
710 }
711 counter += retval;
712 }
713
714out:
715 spinlock_unlock(&printflock);
716 interrupts_restore(irqpri);
717
718 return counter;
719}
720
721/** @}
722 */
Note: See TracBrowser for help on using the repository browser.