1 /******************************************************************************
3 * Module Name: utprint - Formatted printing routines
5 *****************************************************************************/
8 * Copyright (C) 2000 - 2014, Intel Corp.
11 * Redistribution and use in source and binary forms, with or without
12 * modification, are permitted provided that the following conditions
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.
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.
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.
44 #include <acpi/acpi.h>
47 #define _COMPONENT ACPI_UTILITIES
48 ACPI_MODULE_NAME("utprint")
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 */
59 acpi_ut_bound_string_length(const char *string
, acpi_size count
);
61 static char *acpi_ut_bound_string_output(char *string
, const char *end
, char c
);
63 static char *acpi_ut_format_number(char *string
,
66 u8 base
, s32 width
, s32 precision
, u8 type
);
68 static char *acpi_ut_put_number(char *string
, u64 number
, u8 base
, u8 upper
);
72 static const char acpi_gbl_lower_hex_digits
[] = "0123456789abcdef";
73 static const char acpi_gbl_upper_hex_digits
[] = "0123456789ABCDEF";
75 /*******************************************************************************
77 * FUNCTION: acpi_ut_bound_string_length
79 * PARAMETERS: string - String with boundary
80 * count - Boundary of the string
82 * RETURN: Length of the string. Less than or equal to Count.
84 * DESCRIPTION: Calculate the length of a string with boundary.
86 ******************************************************************************/
89 acpi_ut_bound_string_length(const char *string
, acpi_size count
)
93 while (*string
&& count
) {
102 /*******************************************************************************
104 * FUNCTION: acpi_ut_bound_string_output
106 * PARAMETERS: string - String with boundary
107 * end - Boundary of the string
108 * c - Character to be output to the string
110 * RETURN: Updated position for next valid character
112 * DESCRIPTION: Output a character into a string with boundary check.
114 ******************************************************************************/
116 static char *acpi_ut_bound_string_output(char *string
, const char *end
, char c
)
127 /*******************************************************************************
129 * FUNCTION: acpi_ut_put_number
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
136 * RETURN: Updated position for next valid character
138 * DESCRIPTION: Convert an integer into a string, note that, the string holds a
139 * reversed ordered number without the trailing zero.
141 ******************************************************************************/
143 static char *acpi_ut_put_number(char *string
, u64 number
, u8 base
, u8 upper
)
150 digits
= upper
? acpi_gbl_upper_hex_digits
: acpi_gbl_lower_hex_digits
;
156 (void)acpi_ut_divide(number
, base
, &number
,
158 *(pos
++) = digits
[digit_index
];
162 /* *(Pos++) = '0'; */
166 /*******************************************************************************
168 * FUNCTION: acpi_ut_scan_number
170 * PARAMETERS: string - String buffer
171 * number_ptr - Where the number is returned
173 * RETURN: Updated position for next valid character
175 * DESCRIPTION: Scan a string for a decimal integer.
177 ******************************************************************************/
179 const char *acpi_ut_scan_number(const char *string
, u64
*number_ptr
)
183 while (ACPI_IS_DIGIT(*string
)) {
185 number
+= *(string
++) - '0';
188 *number_ptr
= number
;
192 /*******************************************************************************
194 * FUNCTION: acpi_ut_print_number
196 * PARAMETERS: string - String buffer
197 * number - The number to be converted
199 * RETURN: Updated position for next valid character
201 * DESCRIPTION: Print a decimal integer into a string.
203 ******************************************************************************/
205 const char *acpi_ut_print_number(char *string
, u64 number
)
207 char ascii_string
[20];
211 pos1
= acpi_ut_put_number(ascii_string
, number
, 10, FALSE
);
214 while (pos1
!= ascii_string
) {
215 *(pos2
++) = *(--pos1
);
222 /*******************************************************************************
224 * FUNCTION: acpi_ut_format_number
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
234 * RETURN: Updated position for next valid character
236 * DESCRIPTION: Print an integer into a string with any base and any precision.
238 ******************************************************************************/
240 static char *acpi_ut_format_number(char *string
,
243 u8 base
, s32 width
, s32 precision
, u8 type
)
250 char reversed_string
[66];
252 /* Parameter validation */
254 if (base
< 2 || base
> 16) {
258 if (type
& ACPI_FORMAT_LEFT
) {
259 type
&= ~ACPI_FORMAT_ZERO
;
262 need_prefix
= ((type
& ACPI_FORMAT_PREFIX
)
263 && base
!= 10) ? TRUE
: FALSE
;
264 upper
= (type
& ACPI_FORMAT_UPPER
) ? TRUE
: FALSE
;
265 zero
= (type
& ACPI_FORMAT_ZERO
) ? '0' : ' ';
267 /* Calculate size according to sign and prefix */
270 if (type
& ACPI_FORMAT_SIGN
) {
271 if ((s64
) number
< 0) {
273 number
= -(s64
) number
;
275 } else if (type
& ACPI_FORMAT_SIGN_PLUS
) {
278 } else if (type
& ACPI_FORMAT_SIGN_PLUS_SPACE
) {
290 /* Generate full string in reverse order */
292 i
= ACPI_PTR_DIFF(acpi_ut_put_number
293 (reversed_string
, number
, base
, upper
),
296 /* Printing 100 using %2d gives "100", not "00" */
304 /* Output the string */
306 if (!(type
& (ACPI_FORMAT_ZERO
| ACPI_FORMAT_LEFT
))) {
307 while (--width
>= 0) {
308 string
= acpi_ut_bound_string_output(string
, end
, ' ');
312 string
= acpi_ut_bound_string_output(string
, end
, sign
);
315 string
= acpi_ut_bound_string_output(string
, end
, '0');
317 string
= acpi_ut_bound_string_output(string
, end
,
321 if (!(type
& ACPI_FORMAT_LEFT
)) {
322 while (--width
>= 0) {
323 string
= acpi_ut_bound_string_output(string
, end
, zero
);
327 while (i
<= --precision
) {
328 string
= acpi_ut_bound_string_output(string
, end
, '0');
331 string
= acpi_ut_bound_string_output(string
, end
,
334 while (--width
>= 0) {
335 string
= acpi_ut_bound_string_output(string
, end
, ' ');
341 /*******************************************************************************
343 * FUNCTION: acpi_ut_vsnprintf
345 * PARAMETERS: string - String with boundary
346 * size - Boundary of the string
347 * format - Standard printf format
348 * args - Argument list
350 * RETURN: Number of bytes actually written.
352 * DESCRIPTION: Formatted output to a string using argument list pointer.
354 ******************************************************************************/
357 acpi_ut_vsnprintf(char *string
,
358 acpi_size size
, const char *format
, va_list args
)
377 for (; *format
; ++format
) {
378 if (*format
!= '%') {
379 pos
= acpi_ut_bound_string_output(pos
, end
, *format
);
387 if (*format
== '#') {
388 type
|= ACPI_FORMAT_PREFIX
;
389 } else if (*format
== '0') {
390 type
|= ACPI_FORMAT_ZERO
;
391 } else if (*format
== '+') {
392 type
|= ACPI_FORMAT_SIGN_PLUS
;
393 } else if (*format
== ' ') {
394 type
|= ACPI_FORMAT_SIGN_PLUS_SPACE
;
395 } else if (*format
== '-') {
396 type
|= ACPI_FORMAT_LEFT
;
404 if (ACPI_IS_DIGIT(*format
)) {
405 format
= acpi_ut_scan_number(format
, &number
);
406 width
= (s32
) number
;
407 } else if (*format
== '*') {
409 width
= va_arg(args
, int);
412 type
|= ACPI_FORMAT_LEFT
;
416 /* Process precision */
418 if (*format
== '.') {
420 if (ACPI_IS_DIGIT(*format
)) {
421 format
= acpi_ut_scan_number(format
, &number
);
422 precision
= (s32
) number
;
423 } else if (*format
== '*') {
425 precision
= va_arg(args
, int);
432 /* Process qualifier */
434 if (*format
== 'h' || *format
== 'l' || *format
== 'L') {
438 if (qualifier
== 'l' && *format
== 'l') {
447 pos
= acpi_ut_bound_string_output(pos
, end
, '%');
452 if (!(type
& ACPI_FORMAT_LEFT
)) {
453 while (--width
> 0) {
455 acpi_ut_bound_string_output(pos
,
461 c
= (char)va_arg(args
, int);
462 pos
= acpi_ut_bound_string_output(pos
, end
, c
);
464 while (--width
> 0) {
466 acpi_ut_bound_string_output(pos
, end
, ' ');
472 s
= va_arg(args
, char *);
476 length
= acpi_ut_bound_string_length(s
, precision
);
477 if (!(type
& ACPI_FORMAT_LEFT
)) {
478 while (length
< width
--) {
480 acpi_ut_bound_string_output(pos
,
485 for (i
= 0; i
< length
; ++i
) {
486 pos
= acpi_ut_bound_string_output(pos
, end
, *s
);
489 while (length
< width
--) {
491 acpi_ut_bound_string_output(pos
, end
, ' ');
502 type
|= ACPI_FORMAT_UPPER
;
512 type
|= ACPI_FORMAT_SIGN
;
521 width
= 2 * sizeof(void *);
522 type
|= ACPI_FORMAT_ZERO
;
525 p
= va_arg(args
, void *);
526 pos
= acpi_ut_format_number(pos
, end
,
527 ACPI_TO_INTEGER(p
), 16,
528 width
, precision
, type
);
533 pos
= acpi_ut_bound_string_output(pos
, end
, '%');
536 acpi_ut_bound_string_output(pos
, end
,
544 if (qualifier
== 'L') {
545 number
= va_arg(args
, u64
);
546 if (type
& ACPI_FORMAT_SIGN
) {
547 number
= (s64
) number
;
549 } else if (qualifier
== 'l') {
550 number
= va_arg(args
, unsigned long);
551 if (type
& ACPI_FORMAT_SIGN
) {
552 number
= (s32
) number
;
554 } else if (qualifier
== 'h') {
555 number
= (u16
)va_arg(args
, int);
556 if (type
& ACPI_FORMAT_SIGN
) {
557 number
= (s16
) number
;
560 number
= va_arg(args
, unsigned int);
561 if (type
& ACPI_FORMAT_SIGN
) {
562 number
= (signed int)number
;
566 pos
= acpi_ut_format_number(pos
, end
, number
, base
,
567 width
, precision
, type
);
578 return (ACPI_PTR_DIFF(pos
, string
));
581 /*******************************************************************************
583 * FUNCTION: acpi_ut_snprintf
585 * PARAMETERS: string - String with boundary
586 * size - Boundary of the string
587 * Format, ... - Standard printf format
589 * RETURN: Number of bytes actually written.
591 * DESCRIPTION: Formatted output to a string.
593 ******************************************************************************/
595 int acpi_ut_snprintf(char *string
, acpi_size size
, const char *format
, ...)
600 va_start(args
, format
);
601 length
= acpi_ut_vsnprintf(string
, size
, format
, args
);
607 #ifdef ACPI_APPLICATION
608 /*******************************************************************************
610 * FUNCTION: acpi_ut_file_vprintf
612 * PARAMETERS: file - File descriptor
613 * format - Standard printf format
614 * args - Argument list
616 * RETURN: Number of bytes actually written.
618 * DESCRIPTION: Formatted output to a file using argument list pointer.
620 ******************************************************************************/
622 int acpi_ut_file_vprintf(ACPI_FILE file
, const char *format
, va_list args
)
624 acpi_cpu_flags flags
;
627 flags
= acpi_os_acquire_lock(acpi_gbl_print_lock
);
628 length
= acpi_ut_vsnprintf(acpi_gbl_print_buffer
,
629 sizeof(acpi_gbl_print_buffer
), format
, args
);
631 (void)acpi_os_write_file(file
, acpi_gbl_print_buffer
, length
, 1);
632 acpi_os_release_lock(acpi_gbl_print_lock
, flags
);
637 /*******************************************************************************
639 * FUNCTION: acpi_ut_file_printf
641 * PARAMETERS: file - File descriptor
642 * Format, ... - Standard printf format
644 * RETURN: Number of bytes actually written.
646 * DESCRIPTION: Formatted output to a file.
648 ******************************************************************************/
650 int acpi_ut_file_printf(ACPI_FILE file
, const char *format
, ...)
655 va_start(args
, format
);
656 length
= acpi_ut_file_vprintf(file
, format
, args
);