1 /******************************************************************************
2 *
3 * Module Name: utprint - Formatted printing routines
4 *
5 *****************************************************************************/
6
7 /*
8 * Copyright (C) 2000 - 2014, 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
48 ACPI_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 */
58 static acpi_size
59 acpi_ut_bound_string_length(const char *string, acpi_size count);
60
61 static char *acpi_ut_bound_string_output(char *string, const char *end, char c);
62
63 static char *acpi_ut_format_number(char *string,
64 char *end,
65 u64 number,
66 u8 base, s32 width, s32 precision, u8 type);
67
68 static char *acpi_ut_put_number(char *string, u64 number, u8 base, u8 upper);
69
70 /* Module globals */
71
72 static const char acpi_gbl_lower_hex_digits[] = "0123456789abcdef";
73 static 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
88 static acpi_size
acpi_ut_bound_string_length(const char * string,acpi_size count)89 acpi_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
acpi_ut_bound_string_output(char * string,const char * end,char c)116 static 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
acpi_ut_put_number(char * string,u64 number,u8 base,u8 upper)143 static 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
acpi_ut_scan_number(const char * string,u64 * number_ptr)179 const char *acpi_ut_scan_number(const char *string, u64 *number_ptr)
180 {
181 u64 number = 0;
182
183 while (ACPI_IS_DIGIT(*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
acpi_ut_print_number(char * string,u64 number)205 const 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
acpi_ut_format_number(char * string,char * end,u64 number,u8 base,s32 width,s32 precision,u8 type)240 static 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 = acpi_ut_bound_string_output(string, end,
318 upper ? 'X' : 'x');
319 }
320 }
321 if (!(type & ACPI_FORMAT_LEFT)) {
322 while (--width >= 0) {
323 string = acpi_ut_bound_string_output(string, end, zero);
324 }
325 }
326
327 while (i <= --precision) {
328 string = acpi_ut_bound_string_output(string, end, '0');
329 }
330 while (--i >= 0) {
331 string = acpi_ut_bound_string_output(string, end,
332 reversed_string[i]);
333 }
334 while (--width >= 0) {
335 string = acpi_ut_bound_string_output(string, end, ' ');
336 }
337
338 return (string);
339 }
340
341 /*******************************************************************************
342 *
343 * FUNCTION: acpi_ut_vsnprintf
344 *
345 * PARAMETERS: string - String with boundary
346 * size - Boundary of the string
347 * format - Standard printf format
348 * args - Argument list
349 *
350 * RETURN: Number of bytes actually written.
351 *
352 * DESCRIPTION: Formatted output to a string using argument list pointer.
353 *
354 ******************************************************************************/
355
356 int
acpi_ut_vsnprintf(char * string,acpi_size size,const char * format,va_list args)357 acpi_ut_vsnprintf(char *string,
358 acpi_size size, const char *format, va_list args)
359 {
360 u8 base = 10;
361 u8 type = 0;
362 s32 width = -1;
363 s32 precision = -1;
364 char qualifier = 0;
365 u64 number;
366 char *pos;
367 char *end;
368 char c;
369 const char *s;
370 const void *p;
371 s32 length;
372 int i;
373
374 pos = string;
375 end = string + size;
376
377 for (; *format; ++format) {
378 if (*format != '%') {
379 pos = acpi_ut_bound_string_output(pos, end, *format);
380 continue;
381 }
382
383 /* Process sign */
384
385 do {
386 ++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;
397 } else {
398 break;
399 }
400 } while (1);
401
402 /* Process width */
403
404 width = -1;
405 if (ACPI_IS_DIGIT(*format)) {
406 format = acpi_ut_scan_number(format, &number);
407 width = (s32) number;
408 } else if (*format == '*') {
409 ++format;
410 width = va_arg(args, int);
411 if (width < 0) {
412 width = -width;
413 type |= ACPI_FORMAT_LEFT;
414 }
415 }
416
417 /* Process precision */
418
419 precision = -1;
420 if (*format == '.') {
421 ++format;
422 if (ACPI_IS_DIGIT(*format)) {
423 format = acpi_ut_scan_number(format, &number);
424 precision = (s32) number;
425 } else if (*format == '*') {
426 ++format;
427 precision = va_arg(args, int);
428 }
429 if (precision < 0) {
430 precision = 0;
431 }
432 }
433
434 /* Process qualifier */
435
436 qualifier = -1;
437 if (*format == 'h' || *format == 'l' || *format == 'L') {
438 qualifier = *format;
439 ++format;
440
441 if (qualifier == 'l' && *format == 'l') {
442 qualifier = 'L';
443 ++format;
444 }
445 }
446
447 switch (*format) {
448 case '%':
449
450 pos = acpi_ut_bound_string_output(pos, end, '%');
451 continue;
452
453 case 'c':
454
455 if (!(type & ACPI_FORMAT_LEFT)) {
456 while (--width > 0) {
457 pos =
458 acpi_ut_bound_string_output(pos,
459 end,
460 ' ');
461 }
462 }
463
464 c = (char)va_arg(args, int);
465 pos = acpi_ut_bound_string_output(pos, end, c);
466
467 while (--width > 0) {
468 pos =
469 acpi_ut_bound_string_output(pos, end, ' ');
470 }
471 continue;
472
473 case 's':
474
475 s = va_arg(args, char *);
476 if (!s) {
477 s = "<NULL>";
478 }
479 length = acpi_ut_bound_string_length(s, precision);
480 if (!(type & ACPI_FORMAT_LEFT)) {
481 while (length < width--) {
482 pos =
483 acpi_ut_bound_string_output(pos,
484 end,
485 ' ');
486 }
487 }
488 for (i = 0; i < length; ++i) {
489 pos = acpi_ut_bound_string_output(pos, end, *s);
490 ++s;
491 }
492 while (length < width--) {
493 pos =
494 acpi_ut_bound_string_output(pos, end, ' ');
495 }
496 continue;
497
498 case 'o':
499
500 base = 8;
501 break;
502
503 case 'X':
504
505 type |= ACPI_FORMAT_UPPER;
506
507 case 'x':
508
509 base = 16;
510 break;
511
512 case 'd':
513 case 'i':
514
515 type |= ACPI_FORMAT_SIGN;
516
517 case 'u':
518
519 break;
520
521 case 'p':
522
523 if (width == -1) {
524 width = 2 * sizeof(void *);
525 type |= ACPI_FORMAT_ZERO;
526 }
527
528 p = va_arg(args, void *);
529 pos = acpi_ut_format_number(pos, end,
530 ACPI_TO_INTEGER(p), 16,
531 width, precision, type);
532 continue;
533
534 default:
535
536 pos = acpi_ut_bound_string_output(pos, end, '%');
537 if (*format) {
538 pos =
539 acpi_ut_bound_string_output(pos, end,
540 *format);
541 } else {
542 --format;
543 }
544 continue;
545 }
546
547 if (qualifier == 'L') {
548 number = va_arg(args, u64);
549 if (type & ACPI_FORMAT_SIGN) {
550 number = (s64) number;
551 }
552 } else if (qualifier == 'l') {
553 number = va_arg(args, unsigned long);
554 if (type & ACPI_FORMAT_SIGN) {
555 number = (s32) number;
556 }
557 } else if (qualifier == 'h') {
558 number = (u16)va_arg(args, int);
559 if (type & ACPI_FORMAT_SIGN) {
560 number = (s16) number;
561 }
562 } else {
563 number = va_arg(args, unsigned int);
564 if (type & ACPI_FORMAT_SIGN) {
565 number = (signed int)number;
566 }
567 }
568
569 pos = acpi_ut_format_number(pos, end, number, base,
570 width, precision, type);
571 }
572
573 if (size > 0) {
574 if (pos < end) {
575 *pos = '\0';
576 } else {
577 end[-1] = '\0';
578 }
579 }
580
581 return (ACPI_PTR_DIFF(pos, string));
582 }
583
584 /*******************************************************************************
585 *
586 * FUNCTION: acpi_ut_snprintf
587 *
588 * PARAMETERS: string - String with boundary
589 * size - Boundary of the string
590 * Format, ... - Standard printf format
591 *
592 * RETURN: Number of bytes actually written.
593 *
594 * DESCRIPTION: Formatted output to a string.
595 *
596 ******************************************************************************/
597
acpi_ut_snprintf(char * string,acpi_size size,const char * format,...)598 int acpi_ut_snprintf(char *string, acpi_size size, const char *format, ...)
599 {
600 va_list args;
601 int length;
602
603 va_start(args, format);
604 length = acpi_ut_vsnprintf(string, size, format, args);
605 va_end(args);
606
607 return (length);
608 }
609
610 #ifdef ACPI_APPLICATION
611 /*******************************************************************************
612 *
613 * FUNCTION: acpi_ut_file_vprintf
614 *
615 * PARAMETERS: file - File descriptor
616 * format - Standard printf format
617 * args - Argument list
618 *
619 * RETURN: Number of bytes actually written.
620 *
621 * DESCRIPTION: Formatted output to a file using argument list pointer.
622 *
623 ******************************************************************************/
624
acpi_ut_file_vprintf(ACPI_FILE file,const char * format,va_list args)625 int acpi_ut_file_vprintf(ACPI_FILE file, const char *format, va_list args)
626 {
627 acpi_cpu_flags flags;
628 int length;
629
630 flags = acpi_os_acquire_lock(acpi_gbl_print_lock);
631 length = acpi_ut_vsnprintf(acpi_gbl_print_buffer,
632 sizeof(acpi_gbl_print_buffer), format, args);
633
634 (void)acpi_os_write_file(file, acpi_gbl_print_buffer, length, 1);
635 acpi_os_release_lock(acpi_gbl_print_lock, flags);
636
637 return (length);
638 }
639
640 /*******************************************************************************
641 *
642 * FUNCTION: acpi_ut_file_printf
643 *
644 * PARAMETERS: file - File descriptor
645 * Format, ... - Standard printf format
646 *
647 * RETURN: Number of bytes actually written.
648 *
649 * DESCRIPTION: Formatted output to a file.
650 *
651 ******************************************************************************/
652
acpi_ut_file_printf(ACPI_FILE file,const char * format,...)653 int acpi_ut_file_printf(ACPI_FILE file, const char *format, ...)
654 {
655 va_list args;
656 int length;
657
658 va_start(args, format);
659 length = acpi_ut_file_vprintf(file, format, args);
660 va_end(args);
661
662 return (length);
663 }
664 #endif
665