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 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 = 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 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 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 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