1 // SPDX-License-Identifier: BSD-3-Clause OR GPL-2.0
2 /******************************************************************************
3 *
4 * Module Name: utprint - Formatted printing routines
5 *
6 * Copyright (C) 2000 - 2019, Intel Corp.
7 *
8 *****************************************************************************/
9
10 #include <acpi/acpi.h>
11 #include "accommon.h"
12
13 #define _COMPONENT ACPI_UTILITIES
14 ACPI_MODULE_NAME("utprint")
15
16 #define ACPI_FORMAT_SIGN 0x01
17 #define ACPI_FORMAT_SIGN_PLUS 0x02
18 #define ACPI_FORMAT_SIGN_PLUS_SPACE 0x04
19 #define ACPI_FORMAT_ZERO 0x08
20 #define ACPI_FORMAT_LEFT 0x10
21 #define ACPI_FORMAT_UPPER 0x20
22 #define ACPI_FORMAT_PREFIX 0x40
23 /* Local prototypes */
24 static acpi_size
25 acpi_ut_bound_string_length(const char *string, acpi_size count);
26
27 static char *acpi_ut_bound_string_output(char *string, const char *end, char c);
28
29 static char *acpi_ut_format_number(char *string,
30 char *end,
31 u64 number,
32 u8 base, s32 width, s32 precision, u8 type);
33
34 static char *acpi_ut_put_number(char *string, u64 number, u8 base, u8 upper);
35
36 /*******************************************************************************
37 *
38 * FUNCTION: acpi_ut_bound_string_length
39 *
40 * PARAMETERS: string - String with boundary
41 * count - Boundary of the string
42 *
43 * RETURN: Length of the string. Less than or equal to Count.
44 *
45 * DESCRIPTION: Calculate the length of a string with boundary.
46 *
47 ******************************************************************************/
48
49 static acpi_size
50 acpi_ut_bound_string_length(const char *string, acpi_size count)
51 {
52 u32 length = 0;
53
54 while (*string && count) {
55 length++;
56 string++;
57 count--;
58 }
59
60 return (length);
61 }
62
63 /*******************************************************************************
64 *
65 * FUNCTION: acpi_ut_bound_string_output
66 *
67 * PARAMETERS: string - String with boundary
68 * end - Boundary of the string
69 * c - Character to be output to the string
70 *
71 * RETURN: Updated position for next valid character
72 *
73 * DESCRIPTION: Output a character into a string with boundary check.
74 *
75 ******************************************************************************/
76
77 static char *acpi_ut_bound_string_output(char *string, const char *end, char c)
78 {
79
80 if (string < end) {
81 *string = c;
82 }
83
84 ++string;
85 return (string);
86 }
87
88 /*******************************************************************************
89 *
90 * FUNCTION: acpi_ut_put_number
91 *
92 * PARAMETERS: string - Buffer to hold reverse-ordered string
93 * number - Integer to be converted
94 * base - Base of the integer
95 * upper - Whether or not using upper cased digits
96 *
97 * RETURN: Updated position for next valid character
98 *
99 * DESCRIPTION: Convert an integer into a string, note that, the string holds a
100 * reversed ordered number without the trailing zero.
101 *
102 ******************************************************************************/
103
104 static char *acpi_ut_put_number(char *string, u64 number, u8 base, u8 upper)
105 {
106 const char *digits;
107 u64 digit_index;
108 char *pos;
109
110 pos = string;
111 digits = upper ? acpi_gbl_upper_hex_digits : acpi_gbl_lower_hex_digits;
112
113 if (number == 0) {
114 *(pos++) = '0';
115 } else {
116 while (number) {
117 (void)acpi_ut_divide(number, base, &number,
118 &digit_index);
119 *(pos++) = digits[digit_index];
120 }
121 }
122
123 /* *(Pos++) = '0'; */
124 return (pos);
125 }
126
127 /*******************************************************************************
128 *
129 * FUNCTION: acpi_ut_scan_number
130 *
131 * PARAMETERS: string - String buffer
132 * number_ptr - Where the number is returned
133 *
134 * RETURN: Updated position for next valid character
135 *
136 * DESCRIPTION: Scan a string for a decimal integer.
137 *
138 ******************************************************************************/
139
140 const char *acpi_ut_scan_number(const char *string, u64 *number_ptr)
141 {
142 u64 number = 0;
143
144 while (isdigit((int)*string)) {
145 acpi_ut_short_multiply(number, 10, &number);
146 number += *(string++) - '0';
147 }
148
149 *number_ptr = number;
150 return (string);
151 }
152
153 /*******************************************************************************
154 *
155 * FUNCTION: acpi_ut_print_number
156 *
157 * PARAMETERS: string - String buffer
158 * number - The number to be converted
159 *
160 * RETURN: Updated position for next valid character
161 *
162 * DESCRIPTION: Print a decimal integer into a string.
163 *
164 ******************************************************************************/
165
166 const char *acpi_ut_print_number(char *string, u64 number)
167 {
168 char ascii_string[20];
169 const char *pos1;
170 char *pos2;
171
172 pos1 = acpi_ut_put_number(ascii_string, number, 10, FALSE);
173 pos2 = string;
174
175 while (pos1 != ascii_string) {
176 *(pos2++) = *(--pos1);
177 }
178
179 *pos2 = 0;
180 return (string);
181 }
182
183 /*******************************************************************************
184 *
185 * FUNCTION: acpi_ut_format_number
186 *
187 * PARAMETERS: string - String buffer with boundary
188 * end - Boundary of the string
189 * number - The number to be converted
190 * base - Base of the integer
191 * width - Field width
192 * precision - Precision of the integer
193 * type - Special printing flags
194 *
195 * RETURN: Updated position for next valid character
196 *
197 * DESCRIPTION: Print an integer into a string with any base and any precision.
198 *
199 ******************************************************************************/
200
201 static char *acpi_ut_format_number(char *string,
202 char *end,
203 u64 number,
204 u8 base, s32 width, s32 precision, u8 type)
205 {
206 char *pos;
207 char sign;
208 char zero;
209 u8 need_prefix;
210 u8 upper;
211 s32 i;
212 char reversed_string[66];
213
214 /* Parameter validation */
215
216 if (base < 2 || base > 16) {
217 return (NULL);
218 }
219
220 if (type & ACPI_FORMAT_LEFT) {
221 type &= ~ACPI_FORMAT_ZERO;
222 }
223
224 need_prefix = ((type & ACPI_FORMAT_PREFIX)
225 && base != 10) ? TRUE : FALSE;
226 upper = (type & ACPI_FORMAT_UPPER) ? TRUE : FALSE;
227 zero = (type & ACPI_FORMAT_ZERO) ? '0' : ' ';
228
229 /* Calculate size according to sign and prefix */
230
231 sign = '\0';
232 if (type & ACPI_FORMAT_SIGN) {
233 if ((s64)number < 0) {
234 sign = '-';
235 number = -(s64)number;
236 width--;
237 } else if (type & ACPI_FORMAT_SIGN_PLUS) {
238 sign = '+';
239 width--;
240 } else if (type & ACPI_FORMAT_SIGN_PLUS_SPACE) {
241 sign = ' ';
242 width--;
243 }
244 }
245 if (need_prefix) {
246 width--;
247 if (base == 16) {
248 width--;
249 }
250 }
251
252 /* Generate full string in reverse order */
253
254 pos = acpi_ut_put_number(reversed_string, number, base, upper);
255 i = (s32)ACPI_PTR_DIFF(pos, reversed_string);
256
257 /* Printing 100 using %2d gives "100", not "00" */
258
259 if (i > precision) {
260 precision = i;
261 }
262
263 width -= precision;
264
265 /* Output the string */
266
267 if (!(type & (ACPI_FORMAT_ZERO | ACPI_FORMAT_LEFT))) {
268 while (--width >= 0) {
269 string = acpi_ut_bound_string_output(string, end, ' ');
270 }
271 }
272 if (sign) {
273 string = acpi_ut_bound_string_output(string, end, sign);
274 }
275 if (need_prefix) {
276 string = acpi_ut_bound_string_output(string, end, '0');
277 if (base == 16) {
278 string =
279 acpi_ut_bound_string_output(string, end,
280 upper ? 'X' : 'x');
281 }
282 }
283 if (!(type & ACPI_FORMAT_LEFT)) {
284 while (--width >= 0) {
285 string = acpi_ut_bound_string_output(string, end, zero);
286 }
287 }
288
289 while (i <= --precision) {
290 string = acpi_ut_bound_string_output(string, end, '0');
291 }
292 while (--i >= 0) {
293 string = acpi_ut_bound_string_output(string, end,
294 reversed_string[i]);
295 }
296 while (--width >= 0) {
297 string = acpi_ut_bound_string_output(string, end, ' ');
298 }
299
300 return (string);
301 }
302
303 /*******************************************************************************
304 *
305 * FUNCTION: vsnprintf
306 *
307 * PARAMETERS: string - String with boundary
308 * size - Boundary of the string
309 * format - Standard printf format
310 * args - Argument list
311 *
312 * RETURN: Number of bytes actually written.
313 *
314 * DESCRIPTION: Formatted output to a string using argument list pointer.
315 *
316 ******************************************************************************/
317
318 int vsnprintf(char *string, acpi_size size, const char *format, va_list args)
319 {
320 u8 base;
321 u8 type;
322 s32 width;
323 s32 precision;
324 char qualifier;
325 u64 number;
326 char *pos;
327 char *end;
328 char c;
329 const char *s;
330 const void *p;
331 s32 length;
332 int i;
333
334 pos = string;
335 end = string + size;
336
337 for (; *format; ++format) {
338 if (*format != '%') {
339 pos = acpi_ut_bound_string_output(pos, end, *format);
340 continue;
341 }
342
343 type = 0;
344 base = 10;
345
346 /* Process sign */
347
348 do {
349 ++format;
350 if (*format == '#') {
351 type |= ACPI_FORMAT_PREFIX;
352 } else if (*format == '0') {
353 type |= ACPI_FORMAT_ZERO;
354 } else if (*format == '+') {
355 type |= ACPI_FORMAT_SIGN_PLUS;
356 } else if (*format == ' ') {
357 type |= ACPI_FORMAT_SIGN_PLUS_SPACE;
358 } else if (*format == '-') {
359 type |= ACPI_FORMAT_LEFT;
360 } else {
361 break;
362 }
363
364 } while (1);
365
366 /* Process width */
367
368 width = -1;
369 if (isdigit((int)*format)) {
370 format = acpi_ut_scan_number(format, &number);
371 width = (s32)number;
372 } else if (*format == '*') {
373 ++format;
374 width = va_arg(args, int);
375 if (width < 0) {
376 width = -width;
377 type |= ACPI_FORMAT_LEFT;
378 }
379 }
380
381 /* Process precision */
382
383 precision = -1;
384 if (*format == '.') {
385 ++format;
386 if (isdigit((int)*format)) {
387 format = acpi_ut_scan_number(format, &number);
388 precision = (s32)number;
389 } else if (*format == '*') {
390 ++format;
391 precision = va_arg(args, int);
392 }
393
394 if (precision < 0) {
395 precision = 0;
396 }
397 }
398
399 /* Process qualifier */
400
401 qualifier = -1;
402 if (*format == 'h' || *format == 'l' || *format == 'L') {
403 qualifier = *format;
404 ++format;
405
406 if (qualifier == 'l' && *format == 'l') {
407 qualifier = 'L';
408 ++format;
409 }
410 }
411
412 switch (*format) {
413 case '%':
414
415 pos = acpi_ut_bound_string_output(pos, end, '%');
416 continue;
417
418 case 'c':
419
420 if (!(type & ACPI_FORMAT_LEFT)) {
421 while (--width > 0) {
422 pos =
423 acpi_ut_bound_string_output(pos,
424 end,
425 ' ');
426 }
427 }
428
429 c = (char)va_arg(args, int);
430 pos = acpi_ut_bound_string_output(pos, end, c);
431
432 while (--width > 0) {
433 pos =
434 acpi_ut_bound_string_output(pos, end, ' ');
435 }
436 continue;
437
438 case 's':
439
440 s = va_arg(args, char *);
441 if (!s) {
442 s = "<NULL>";
443 }
444 length = (s32)acpi_ut_bound_string_length(s, precision);
445 if (!(type & ACPI_FORMAT_LEFT)) {
446 while (length < width--) {
447 pos =
448 acpi_ut_bound_string_output(pos,
449 end,
450 ' ');
451 }
452 }
453
454 for (i = 0; i < length; ++i) {
455 pos = acpi_ut_bound_string_output(pos, end, *s);
456 ++s;
457 }
458
459 while (length < width--) {
460 pos =
461 acpi_ut_bound_string_output(pos, end, ' ');
462 }
463 continue;
464
465 case 'o':
466
467 base = 8;
468 break;
469
470 case 'X':
471
472 type |= ACPI_FORMAT_UPPER;
473 /* FALLTHROUGH */
474
475 case 'x':
476
477 base = 16;
478 break;
479
480 case 'd':
481 case 'i':
482
483 type |= ACPI_FORMAT_SIGN;
484
485 case 'u':
486
487 break;
488
489 case 'p':
490
491 if (width == -1) {
492 width = 2 * sizeof(void *);
493 type |= ACPI_FORMAT_ZERO;
494 }
495
496 p = va_arg(args, void *);
497 pos =
498 acpi_ut_format_number(pos, end, ACPI_TO_INTEGER(p),
499 16, width, precision, type);
500 continue;
501
502 default:
503
504 pos = acpi_ut_bound_string_output(pos, end, '%');
505 if (*format) {
506 pos =
507 acpi_ut_bound_string_output(pos, end,
508 *format);
509 } else {
510 --format;
511 }
512 continue;
513 }
514
515 if (qualifier == 'L') {
516 number = va_arg(args, u64);
517 if (type & ACPI_FORMAT_SIGN) {
518 number = (s64)number;
519 }
520 } else if (qualifier == 'l') {
521 number = va_arg(args, unsigned long);
522 if (type & ACPI_FORMAT_SIGN) {
523 number = (s32)number;
524 }
525 } else if (qualifier == 'h') {
526 number = (u16)va_arg(args, int);
527 if (type & ACPI_FORMAT_SIGN) {
528 number = (s16)number;
529 }
530 } else {
531 number = va_arg(args, unsigned int);
532 if (type & ACPI_FORMAT_SIGN) {
533 number = (signed int)number;
534 }
535 }
536
537 pos = acpi_ut_format_number(pos, end, number, base,
538 width, precision, type);
539 }
540
541 if (size > 0) {
542 if (pos < end) {
543 *pos = '\0';
544 } else {
545 end[-1] = '\0';
546 }
547 }
548
549 return ((int)ACPI_PTR_DIFF(pos, string));
550 }
551
552 /*******************************************************************************
553 *
554 * FUNCTION: snprintf
555 *
556 * PARAMETERS: string - String with boundary
557 * size - Boundary of the string
558 * Format, ... - Standard printf format
559 *
560 * RETURN: Number of bytes actually written.
561 *
562 * DESCRIPTION: Formatted output to a string.
563 *
564 ******************************************************************************/
565
566 int snprintf(char *string, acpi_size size, const char *format, ...)
567 {
568 va_list args;
569 int length;
570
571 va_start(args, format);
572 length = vsnprintf(string, size, format, args);
573 va_end(args);
574
575 return (length);
576 }
577
578 /*******************************************************************************
579 *
580 * FUNCTION: sprintf
581 *
582 * PARAMETERS: string - String with boundary
583 * Format, ... - Standard printf format
584 *
585 * RETURN: Number of bytes actually written.
586 *
587 * DESCRIPTION: Formatted output to a string.
588 *
589 ******************************************************************************/
590
591 int sprintf(char *string, const char *format, ...)
592 {
593 va_list args;
594 int length;
595
596 va_start(args, format);
597 length = vsnprintf(string, ACPI_UINT32_MAX, format, args);
598 va_end(args);
599
600 return (length);
601 }
602
603 #ifdef ACPI_APPLICATION
604 /*******************************************************************************
605 *
606 * FUNCTION: vprintf
607 *
608 * PARAMETERS: format - Standard printf format
609 * args - Argument list
610 *
611 * RETURN: Number of bytes actually written.
612 *
613 * DESCRIPTION: Formatted output to stdout using argument list pointer.
614 *
615 ******************************************************************************/
616
617 int vprintf(const char *format, va_list args)
618 {
619 acpi_cpu_flags flags;
620 int length;
621
622 flags = acpi_os_acquire_lock(acpi_gbl_print_lock);
623 length = vsnprintf(acpi_gbl_print_buffer,
624 sizeof(acpi_gbl_print_buffer), format, args);
625
626 (void)fwrite(acpi_gbl_print_buffer, length, 1, ACPI_FILE_OUT);
627 acpi_os_release_lock(acpi_gbl_print_lock, flags);
628
629 return (length);
630 }
631
632 /*******************************************************************************
633 *
634 * FUNCTION: printf
635 *
636 * PARAMETERS: Format, ... - Standard printf format
637 *
638 * RETURN: Number of bytes actually written.
639 *
640 * DESCRIPTION: Formatted output to stdout.
641 *
642 ******************************************************************************/
643
644 int printf(const char *format, ...)
645 {
646 va_list args;
647 int length;
648
649 va_start(args, format);
650 length = vprintf(format, args);
651 va_end(args);
652
653 return (length);
654 }
655
656 /*******************************************************************************
657 *
658 * FUNCTION: vfprintf
659 *
660 * PARAMETERS: file - File descriptor
661 * format - Standard printf format
662 * args - Argument list
663 *
664 * RETURN: Number of bytes actually written.
665 *
666 * DESCRIPTION: Formatted output to a file using argument list pointer.
667 *
668 ******************************************************************************/
669
670 int vfprintf(FILE * file, const char *format, va_list args)
671 {
672 acpi_cpu_flags flags;
673 int length;
674
675 flags = acpi_os_acquire_lock(acpi_gbl_print_lock);
676 length = vsnprintf(acpi_gbl_print_buffer,
677 sizeof(acpi_gbl_print_buffer), format, args);
678
679 (void)fwrite(acpi_gbl_print_buffer, length, 1, file);
680 acpi_os_release_lock(acpi_gbl_print_lock, flags);
681
682 return (length);
683 }
684
685 /*******************************************************************************
686 *
687 * FUNCTION: fprintf
688 *
689 * PARAMETERS: file - File descriptor
690 * Format, ... - Standard printf format
691 *
692 * RETURN: Number of bytes actually written.
693 *
694 * DESCRIPTION: Formatted output to a file.
695 *
696 ******************************************************************************/
697
698 int fprintf(FILE * file, const char *format, ...)
699 {
700 va_list args;
701 int length;
702
703 va_start(args, format);
704 length = vfprintf(file, format, args);
705 va_end(args);
706
707 return (length);
708 }
709 #endif