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