1 /****************************************************************************** 2 * 3 * Module Name: utprint - Formatted printing routines 4 * 5 *****************************************************************************/ 6 7 /* 8 * Copyright (C) 2000 - 2015, 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 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 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 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 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 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 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 357 acpi_ut_vsnprintf(char *string, 358 acpi_size size, const char *format, va_list args) 359 { 360 u8 base; 361 u8 type; 362 s32 width; 363 s32 precision; 364 char qualifier; 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 type = 0; 384 base = 10; 385 386 /* Process sign */ 387 388 do { 389 ++format; 390 if (*format == '#') { 391 type |= ACPI_FORMAT_PREFIX; 392 } else if (*format == '0') { 393 type |= ACPI_FORMAT_ZERO; 394 } else if (*format == '+') { 395 type |= ACPI_FORMAT_SIGN_PLUS; 396 } else if (*format == ' ') { 397 type |= ACPI_FORMAT_SIGN_PLUS_SPACE; 398 } else if (*format == '-') { 399 type |= ACPI_FORMAT_LEFT; 400 } else { 401 break; 402 } 403 } while (1); 404 405 /* Process width */ 406 407 width = -1; 408 if (ACPI_IS_DIGIT(*format)) { 409 format = acpi_ut_scan_number(format, &number); 410 width = (s32) number; 411 } else if (*format == '*') { 412 ++format; 413 width = va_arg(args, int); 414 if (width < 0) { 415 width = -width; 416 type |= ACPI_FORMAT_LEFT; 417 } 418 } 419 420 /* Process precision */ 421 422 precision = -1; 423 if (*format == '.') { 424 ++format; 425 if (ACPI_IS_DIGIT(*format)) { 426 format = acpi_ut_scan_number(format, &number); 427 precision = (s32) number; 428 } else if (*format == '*') { 429 ++format; 430 precision = va_arg(args, int); 431 } 432 if (precision < 0) { 433 precision = 0; 434 } 435 } 436 437 /* Process qualifier */ 438 439 qualifier = -1; 440 if (*format == 'h' || *format == 'l' || *format == 'L') { 441 qualifier = *format; 442 ++format; 443 444 if (qualifier == 'l' && *format == 'l') { 445 qualifier = 'L'; 446 ++format; 447 } 448 } 449 450 switch (*format) { 451 case '%': 452 453 pos = acpi_ut_bound_string_output(pos, end, '%'); 454 continue; 455 456 case 'c': 457 458 if (!(type & ACPI_FORMAT_LEFT)) { 459 while (--width > 0) { 460 pos = 461 acpi_ut_bound_string_output(pos, 462 end, 463 ' '); 464 } 465 } 466 467 c = (char)va_arg(args, int); 468 pos = acpi_ut_bound_string_output(pos, end, c); 469 470 while (--width > 0) { 471 pos = 472 acpi_ut_bound_string_output(pos, end, ' '); 473 } 474 continue; 475 476 case 's': 477 478 s = va_arg(args, char *); 479 if (!s) { 480 s = "<NULL>"; 481 } 482 length = acpi_ut_bound_string_length(s, precision); 483 if (!(type & ACPI_FORMAT_LEFT)) { 484 while (length < width--) { 485 pos = 486 acpi_ut_bound_string_output(pos, 487 end, 488 ' '); 489 } 490 } 491 for (i = 0; i < length; ++i) { 492 pos = acpi_ut_bound_string_output(pos, end, *s); 493 ++s; 494 } 495 while (length < width--) { 496 pos = 497 acpi_ut_bound_string_output(pos, end, ' '); 498 } 499 continue; 500 501 case 'o': 502 503 base = 8; 504 break; 505 506 case 'X': 507 508 type |= ACPI_FORMAT_UPPER; 509 510 case 'x': 511 512 base = 16; 513 break; 514 515 case 'd': 516 case 'i': 517 518 type |= ACPI_FORMAT_SIGN; 519 520 case 'u': 521 522 break; 523 524 case 'p': 525 526 if (width == -1) { 527 width = 2 * sizeof(void *); 528 type |= ACPI_FORMAT_ZERO; 529 } 530 531 p = va_arg(args, void *); 532 pos = acpi_ut_format_number(pos, end, 533 ACPI_TO_INTEGER(p), 16, 534 width, precision, type); 535 continue; 536 537 default: 538 539 pos = acpi_ut_bound_string_output(pos, end, '%'); 540 if (*format) { 541 pos = 542 acpi_ut_bound_string_output(pos, end, 543 *format); 544 } else { 545 --format; 546 } 547 continue; 548 } 549 550 if (qualifier == 'L') { 551 number = va_arg(args, u64); 552 if (type & ACPI_FORMAT_SIGN) { 553 number = (s64) number; 554 } 555 } else if (qualifier == 'l') { 556 number = va_arg(args, unsigned long); 557 if (type & ACPI_FORMAT_SIGN) { 558 number = (s32) number; 559 } 560 } else if (qualifier == 'h') { 561 number = (u16)va_arg(args, int); 562 if (type & ACPI_FORMAT_SIGN) { 563 number = (s16) number; 564 } 565 } else { 566 number = va_arg(args, unsigned int); 567 if (type & ACPI_FORMAT_SIGN) { 568 number = (signed int)number; 569 } 570 } 571 572 pos = acpi_ut_format_number(pos, end, number, base, 573 width, precision, type); 574 } 575 576 if (size > 0) { 577 if (pos < end) { 578 *pos = '\0'; 579 } else { 580 end[-1] = '\0'; 581 } 582 } 583 584 return (ACPI_PTR_DIFF(pos, string)); 585 } 586 587 /******************************************************************************* 588 * 589 * FUNCTION: acpi_ut_snprintf 590 * 591 * PARAMETERS: string - String with boundary 592 * size - Boundary of the string 593 * Format, ... - Standard printf format 594 * 595 * RETURN: Number of bytes actually written. 596 * 597 * DESCRIPTION: Formatted output to a string. 598 * 599 ******************************************************************************/ 600 601 int acpi_ut_snprintf(char *string, acpi_size size, const char *format, ...) 602 { 603 va_list args; 604 int length; 605 606 va_start(args, format); 607 length = acpi_ut_vsnprintf(string, size, format, args); 608 va_end(args); 609 610 return (length); 611 } 612 613 #ifdef ACPI_APPLICATION 614 /******************************************************************************* 615 * 616 * FUNCTION: acpi_ut_file_vprintf 617 * 618 * PARAMETERS: file - File descriptor 619 * format - Standard printf format 620 * args - Argument list 621 * 622 * RETURN: Number of bytes actually written. 623 * 624 * DESCRIPTION: Formatted output to a file using argument list pointer. 625 * 626 ******************************************************************************/ 627 628 int acpi_ut_file_vprintf(ACPI_FILE file, const char *format, va_list args) 629 { 630 acpi_cpu_flags flags; 631 int length; 632 633 flags = acpi_os_acquire_lock(acpi_gbl_print_lock); 634 length = acpi_ut_vsnprintf(acpi_gbl_print_buffer, 635 sizeof(acpi_gbl_print_buffer), format, args); 636 637 (void)acpi_os_write_file(file, acpi_gbl_print_buffer, length, 1); 638 acpi_os_release_lock(acpi_gbl_print_lock, flags); 639 640 return (length); 641 } 642 643 /******************************************************************************* 644 * 645 * FUNCTION: acpi_ut_file_printf 646 * 647 * PARAMETERS: file - File descriptor 648 * Format, ... - Standard printf format 649 * 650 * RETURN: Number of bytes actually written. 651 * 652 * DESCRIPTION: Formatted output to a file. 653 * 654 ******************************************************************************/ 655 656 int acpi_ut_file_printf(ACPI_FILE file, const char *format, ...) 657 { 658 va_list args; 659 int length; 660 661 va_start(args, format); 662 length = acpi_ut_file_vprintf(file, format, args); 663 va_end(args); 664 665 return (length); 666 } 667 #endif 668