utstring.c revision 245582
1244971Sjkim/******************************************************************************* 2244971Sjkim * 3244971Sjkim * Module Name: utstring - Common functions for strings and characters 4244971Sjkim * 5244971Sjkim ******************************************************************************/ 6244971Sjkim 7244971Sjkim/* 8245582Sjkim * Copyright (C) 2000 - 2013, Intel Corp. 9244971Sjkim * All rights reserved. 10244971Sjkim * 11244971Sjkim * Redistribution and use in source and binary forms, with or without 12244971Sjkim * modification, are permitted provided that the following conditions 13244971Sjkim * are met: 14244971Sjkim * 1. Redistributions of source code must retain the above copyright 15244971Sjkim * notice, this list of conditions, and the following disclaimer, 16244971Sjkim * without modification. 17244971Sjkim * 2. Redistributions in binary form must reproduce at minimum a disclaimer 18244971Sjkim * substantially similar to the "NO WARRANTY" disclaimer below 19244971Sjkim * ("Disclaimer") and any redistribution must be conditioned upon 20244971Sjkim * including a substantially similar Disclaimer requirement for further 21244971Sjkim * binary redistribution. 22244971Sjkim * 3. Neither the names of the above-listed copyright holders nor the names 23244971Sjkim * of any contributors may be used to endorse or promote products derived 24244971Sjkim * from this software without specific prior written permission. 25244971Sjkim * 26244971Sjkim * Alternatively, this software may be distributed under the terms of the 27244971Sjkim * GNU General Public License ("GPL") version 2 as published by the Free 28244971Sjkim * Software Foundation. 29244971Sjkim * 30244971Sjkim * NO WARRANTY 31244971Sjkim * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS 32244971Sjkim * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT 33244971Sjkim * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTIBILITY AND FITNESS FOR 34244971Sjkim * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT 35244971Sjkim * HOLDERS OR CONTRIBUTORS BE LIABLE FOR SPECIAL, EXEMPLARY, OR CONSEQUENTIAL 36244971Sjkim * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS 37244971Sjkim * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) 38244971Sjkim * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, 39244971Sjkim * STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING 40244971Sjkim * IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE 41244971Sjkim * POSSIBILITY OF SUCH DAMAGES. 42244971Sjkim */ 43244971Sjkim 44244971Sjkim 45244971Sjkim#define __UTSTRING_C__ 46244971Sjkim 47245582Sjkim#include <contrib/dev/acpica/include/acpi.h> 48245582Sjkim#include <contrib/dev/acpica/include/accommon.h> 49245582Sjkim#include <contrib/dev/acpica/include/acnamesp.h> 50244971Sjkim 51244971Sjkim 52244971Sjkim#define _COMPONENT ACPI_UTILITIES 53244971Sjkim ACPI_MODULE_NAME ("utstring") 54244971Sjkim 55244971Sjkim 56244971Sjkim/* 57244971Sjkim * Non-ANSI C library functions - strlwr, strupr, stricmp, and a 64-bit 58244971Sjkim * version of strtoul. 59244971Sjkim */ 60244971Sjkim 61244971Sjkim#ifdef ACPI_ASL_COMPILER 62244971Sjkim/******************************************************************************* 63244971Sjkim * 64244971Sjkim * FUNCTION: AcpiUtStrlwr (strlwr) 65244971Sjkim * 66244971Sjkim * PARAMETERS: SrcString - The source string to convert 67244971Sjkim * 68244971Sjkim * RETURN: None 69244971Sjkim * 70244971Sjkim * DESCRIPTION: Convert string to lowercase 71244971Sjkim * 72244971Sjkim * NOTE: This is not a POSIX function, so it appears here, not in utclib.c 73244971Sjkim * 74244971Sjkim ******************************************************************************/ 75244971Sjkim 76244971Sjkimvoid 77244971SjkimAcpiUtStrlwr ( 78244971Sjkim char *SrcString) 79244971Sjkim{ 80244971Sjkim char *String; 81244971Sjkim 82244971Sjkim 83244971Sjkim ACPI_FUNCTION_ENTRY (); 84244971Sjkim 85244971Sjkim 86244971Sjkim if (!SrcString) 87244971Sjkim { 88244971Sjkim return; 89244971Sjkim } 90244971Sjkim 91244971Sjkim /* Walk entire string, lowercasing the letters */ 92244971Sjkim 93244971Sjkim for (String = SrcString; *String; String++) 94244971Sjkim { 95244971Sjkim *String = (char) ACPI_TOLOWER (*String); 96244971Sjkim } 97244971Sjkim 98244971Sjkim return; 99244971Sjkim} 100244971Sjkim 101244971Sjkim 102244971Sjkim/****************************************************************************** 103244971Sjkim * 104244971Sjkim * FUNCTION: AcpiUtStricmp (stricmp) 105244971Sjkim * 106244971Sjkim * PARAMETERS: String1 - first string to compare 107244971Sjkim * String2 - second string to compare 108244971Sjkim * 109244971Sjkim * RETURN: int that signifies string relationship. Zero means strings 110244971Sjkim * are equal. 111244971Sjkim * 112244971Sjkim * DESCRIPTION: Implementation of the non-ANSI stricmp function (compare 113244971Sjkim * strings with no case sensitivity) 114244971Sjkim * 115244971Sjkim ******************************************************************************/ 116244971Sjkim 117244971Sjkimint 118244971SjkimAcpiUtStricmp ( 119244971Sjkim char *String1, 120244971Sjkim char *String2) 121244971Sjkim{ 122244971Sjkim int c1; 123244971Sjkim int c2; 124244971Sjkim 125244971Sjkim 126244971Sjkim do 127244971Sjkim { 128244971Sjkim c1 = tolower ((int) *String1); 129244971Sjkim c2 = tolower ((int) *String2); 130244971Sjkim 131244971Sjkim String1++; 132244971Sjkim String2++; 133244971Sjkim } 134244971Sjkim while ((c1 == c2) && (c1)); 135244971Sjkim 136244971Sjkim return (c1 - c2); 137244971Sjkim} 138244971Sjkim#endif 139244971Sjkim 140244971Sjkim 141244971Sjkim/******************************************************************************* 142244971Sjkim * 143244971Sjkim * FUNCTION: AcpiUtStrupr (strupr) 144244971Sjkim * 145244971Sjkim * PARAMETERS: SrcString - The source string to convert 146244971Sjkim * 147244971Sjkim * RETURN: None 148244971Sjkim * 149244971Sjkim * DESCRIPTION: Convert string to uppercase 150244971Sjkim * 151244971Sjkim * NOTE: This is not a POSIX function, so it appears here, not in utclib.c 152244971Sjkim * 153244971Sjkim ******************************************************************************/ 154244971Sjkim 155244971Sjkimvoid 156244971SjkimAcpiUtStrupr ( 157244971Sjkim char *SrcString) 158244971Sjkim{ 159244971Sjkim char *String; 160244971Sjkim 161244971Sjkim 162244971Sjkim ACPI_FUNCTION_ENTRY (); 163244971Sjkim 164244971Sjkim 165244971Sjkim if (!SrcString) 166244971Sjkim { 167244971Sjkim return; 168244971Sjkim } 169244971Sjkim 170244971Sjkim /* Walk entire string, uppercasing the letters */ 171244971Sjkim 172244971Sjkim for (String = SrcString; *String; String++) 173244971Sjkim { 174244971Sjkim *String = (char) ACPI_TOUPPER (*String); 175244971Sjkim } 176244971Sjkim 177244971Sjkim return; 178244971Sjkim} 179244971Sjkim 180244971Sjkim 181244971Sjkim/******************************************************************************* 182244971Sjkim * 183244971Sjkim * FUNCTION: AcpiUtStrtoul64 184244971Sjkim * 185244971Sjkim * PARAMETERS: String - Null terminated string 186244971Sjkim * Base - Radix of the string: 16 or ACPI_ANY_BASE; 187244971Sjkim * ACPI_ANY_BASE means 'in behalf of ToInteger' 188244971Sjkim * RetInteger - Where the converted integer is returned 189244971Sjkim * 190244971Sjkim * RETURN: Status and Converted value 191244971Sjkim * 192244971Sjkim * DESCRIPTION: Convert a string into an unsigned value. Performs either a 193244971Sjkim * 32-bit or 64-bit conversion, depending on the current mode 194244971Sjkim * of the interpreter. 195244971Sjkim * NOTE: Does not support Octal strings, not needed. 196244971Sjkim * 197244971Sjkim ******************************************************************************/ 198244971Sjkim 199244971SjkimACPI_STATUS 200244971SjkimAcpiUtStrtoul64 ( 201244971Sjkim char *String, 202244971Sjkim UINT32 Base, 203244971Sjkim UINT64 *RetInteger) 204244971Sjkim{ 205244971Sjkim UINT32 ThisDigit = 0; 206244971Sjkim UINT64 ReturnValue = 0; 207244971Sjkim UINT64 Quotient; 208244971Sjkim UINT64 Dividend; 209244971Sjkim UINT32 ToIntegerOp = (Base == ACPI_ANY_BASE); 210244971Sjkim UINT32 Mode32 = (AcpiGbl_IntegerByteWidth == 4); 211244971Sjkim UINT8 ValidDigits = 0; 212244971Sjkim UINT8 SignOf0x = 0; 213244971Sjkim UINT8 Term = 0; 214244971Sjkim 215244971Sjkim 216244971Sjkim ACPI_FUNCTION_TRACE_STR (UtStroul64, String); 217244971Sjkim 218244971Sjkim 219244971Sjkim switch (Base) 220244971Sjkim { 221244971Sjkim case ACPI_ANY_BASE: 222244971Sjkim case 16: 223244971Sjkim break; 224244971Sjkim 225244971Sjkim default: 226244971Sjkim /* Invalid Base */ 227244971Sjkim return_ACPI_STATUS (AE_BAD_PARAMETER); 228244971Sjkim } 229244971Sjkim 230244971Sjkim if (!String) 231244971Sjkim { 232244971Sjkim goto ErrorExit; 233244971Sjkim } 234244971Sjkim 235244971Sjkim /* Skip over any white space in the buffer */ 236244971Sjkim 237244971Sjkim while ((*String) && (ACPI_IS_SPACE (*String) || *String == '\t')) 238244971Sjkim { 239244971Sjkim String++; 240244971Sjkim } 241244971Sjkim 242244971Sjkim if (ToIntegerOp) 243244971Sjkim { 244244971Sjkim /* 245244971Sjkim * Base equal to ACPI_ANY_BASE means 'ToInteger operation case'. 246244971Sjkim * We need to determine if it is decimal or hexadecimal. 247244971Sjkim */ 248244971Sjkim if ((*String == '0') && (ACPI_TOLOWER (*(String + 1)) == 'x')) 249244971Sjkim { 250244971Sjkim SignOf0x = 1; 251244971Sjkim Base = 16; 252244971Sjkim 253244971Sjkim /* Skip over the leading '0x' */ 254244971Sjkim String += 2; 255244971Sjkim } 256244971Sjkim else 257244971Sjkim { 258244971Sjkim Base = 10; 259244971Sjkim } 260244971Sjkim } 261244971Sjkim 262244971Sjkim /* Any string left? Check that '0x' is not followed by white space. */ 263244971Sjkim 264244971Sjkim if (!(*String) || ACPI_IS_SPACE (*String) || *String == '\t') 265244971Sjkim { 266244971Sjkim if (ToIntegerOp) 267244971Sjkim { 268244971Sjkim goto ErrorExit; 269244971Sjkim } 270244971Sjkim else 271244971Sjkim { 272244971Sjkim goto AllDone; 273244971Sjkim } 274244971Sjkim } 275244971Sjkim 276244971Sjkim /* 277244971Sjkim * Perform a 32-bit or 64-bit conversion, depending upon the current 278244971Sjkim * execution mode of the interpreter 279244971Sjkim */ 280244971Sjkim Dividend = (Mode32) ? ACPI_UINT32_MAX : ACPI_UINT64_MAX; 281244971Sjkim 282244971Sjkim /* Main loop: convert the string to a 32- or 64-bit integer */ 283244971Sjkim 284244971Sjkim while (*String) 285244971Sjkim { 286244971Sjkim if (ACPI_IS_DIGIT (*String)) 287244971Sjkim { 288244971Sjkim /* Convert ASCII 0-9 to Decimal value */ 289244971Sjkim 290244971Sjkim ThisDigit = ((UINT8) *String) - '0'; 291244971Sjkim } 292244971Sjkim else if (Base == 10) 293244971Sjkim { 294244971Sjkim /* Digit is out of range; possible in ToInteger case only */ 295244971Sjkim 296244971Sjkim Term = 1; 297244971Sjkim } 298244971Sjkim else 299244971Sjkim { 300244971Sjkim ThisDigit = (UINT8) ACPI_TOUPPER (*String); 301244971Sjkim if (ACPI_IS_XDIGIT ((char) ThisDigit)) 302244971Sjkim { 303244971Sjkim /* Convert ASCII Hex char to value */ 304244971Sjkim 305244971Sjkim ThisDigit = ThisDigit - 'A' + 10; 306244971Sjkim } 307244971Sjkim else 308244971Sjkim { 309244971Sjkim Term = 1; 310244971Sjkim } 311244971Sjkim } 312244971Sjkim 313244971Sjkim if (Term) 314244971Sjkim { 315244971Sjkim if (ToIntegerOp) 316244971Sjkim { 317244971Sjkim goto ErrorExit; 318244971Sjkim } 319244971Sjkim else 320244971Sjkim { 321244971Sjkim break; 322244971Sjkim } 323244971Sjkim } 324244971Sjkim else if ((ValidDigits == 0) && (ThisDigit == 0) && !SignOf0x) 325244971Sjkim { 326244971Sjkim /* Skip zeros */ 327244971Sjkim String++; 328244971Sjkim continue; 329244971Sjkim } 330244971Sjkim 331244971Sjkim ValidDigits++; 332244971Sjkim 333244971Sjkim if (SignOf0x && ((ValidDigits > 16) || ((ValidDigits > 8) && Mode32))) 334244971Sjkim { 335244971Sjkim /* 336244971Sjkim * This is ToInteger operation case. 337244971Sjkim * No any restrictions for string-to-integer conversion, 338244971Sjkim * see ACPI spec. 339244971Sjkim */ 340244971Sjkim goto ErrorExit; 341244971Sjkim } 342244971Sjkim 343244971Sjkim /* Divide the digit into the correct position */ 344244971Sjkim 345244971Sjkim (void) AcpiUtShortDivide ((Dividend - (UINT64) ThisDigit), 346244971Sjkim Base, &Quotient, NULL); 347244971Sjkim 348244971Sjkim if (ReturnValue > Quotient) 349244971Sjkim { 350244971Sjkim if (ToIntegerOp) 351244971Sjkim { 352244971Sjkim goto ErrorExit; 353244971Sjkim } 354244971Sjkim else 355244971Sjkim { 356244971Sjkim break; 357244971Sjkim } 358244971Sjkim } 359244971Sjkim 360244971Sjkim ReturnValue *= Base; 361244971Sjkim ReturnValue += ThisDigit; 362244971Sjkim String++; 363244971Sjkim } 364244971Sjkim 365244971Sjkim /* All done, normal exit */ 366244971Sjkim 367244971SjkimAllDone: 368244971Sjkim 369244971Sjkim ACPI_DEBUG_PRINT ((ACPI_DB_EXEC, "Converted value: %8.8X%8.8X\n", 370244971Sjkim ACPI_FORMAT_UINT64 (ReturnValue))); 371244971Sjkim 372244971Sjkim *RetInteger = ReturnValue; 373244971Sjkim return_ACPI_STATUS (AE_OK); 374244971Sjkim 375244971Sjkim 376244971SjkimErrorExit: 377244971Sjkim /* Base was set/validated above */ 378244971Sjkim 379244971Sjkim if (Base == 10) 380244971Sjkim { 381244971Sjkim return_ACPI_STATUS (AE_BAD_DECIMAL_CONSTANT); 382244971Sjkim } 383244971Sjkim else 384244971Sjkim { 385244971Sjkim return_ACPI_STATUS (AE_BAD_HEX_CONSTANT); 386244971Sjkim } 387244971Sjkim} 388244971Sjkim 389244971Sjkim 390244971Sjkim/******************************************************************************* 391244971Sjkim * 392244971Sjkim * FUNCTION: AcpiUtPrintString 393244971Sjkim * 394244971Sjkim * PARAMETERS: String - Null terminated ASCII string 395244971Sjkim * MaxLength - Maximum output length 396244971Sjkim * 397244971Sjkim * RETURN: None 398244971Sjkim * 399244971Sjkim * DESCRIPTION: Dump an ASCII string with support for ACPI-defined escape 400244971Sjkim * sequences. 401244971Sjkim * 402244971Sjkim ******************************************************************************/ 403244971Sjkim 404244971Sjkimvoid 405244971SjkimAcpiUtPrintString ( 406244971Sjkim char *String, 407244971Sjkim UINT8 MaxLength) 408244971Sjkim{ 409244971Sjkim UINT32 i; 410244971Sjkim 411244971Sjkim 412244971Sjkim if (!String) 413244971Sjkim { 414244971Sjkim AcpiOsPrintf ("<\"NULL STRING PTR\">"); 415244971Sjkim return; 416244971Sjkim } 417244971Sjkim 418244971Sjkim AcpiOsPrintf ("\""); 419244971Sjkim for (i = 0; String[i] && (i < MaxLength); i++) 420244971Sjkim { 421244971Sjkim /* Escape sequences */ 422244971Sjkim 423244971Sjkim switch (String[i]) 424244971Sjkim { 425244971Sjkim case 0x07: 426244971Sjkim AcpiOsPrintf ("\\a"); /* BELL */ 427244971Sjkim break; 428244971Sjkim 429244971Sjkim case 0x08: 430244971Sjkim AcpiOsPrintf ("\\b"); /* BACKSPACE */ 431244971Sjkim break; 432244971Sjkim 433244971Sjkim case 0x0C: 434244971Sjkim AcpiOsPrintf ("\\f"); /* FORMFEED */ 435244971Sjkim break; 436244971Sjkim 437244971Sjkim case 0x0A: 438244971Sjkim AcpiOsPrintf ("\\n"); /* LINEFEED */ 439244971Sjkim break; 440244971Sjkim 441244971Sjkim case 0x0D: 442244971Sjkim AcpiOsPrintf ("\\r"); /* CARRIAGE RETURN*/ 443244971Sjkim break; 444244971Sjkim 445244971Sjkim case 0x09: 446244971Sjkim AcpiOsPrintf ("\\t"); /* HORIZONTAL TAB */ 447244971Sjkim break; 448244971Sjkim 449244971Sjkim case 0x0B: 450244971Sjkim AcpiOsPrintf ("\\v"); /* VERTICAL TAB */ 451244971Sjkim break; 452244971Sjkim 453244971Sjkim case '\'': /* Single Quote */ 454244971Sjkim case '\"': /* Double Quote */ 455244971Sjkim case '\\': /* Backslash */ 456244971Sjkim AcpiOsPrintf ("\\%c", (int) String[i]); 457244971Sjkim break; 458244971Sjkim 459244971Sjkim default: 460244971Sjkim 461244971Sjkim /* Check for printable character or hex escape */ 462244971Sjkim 463244971Sjkim if (ACPI_IS_PRINT (String[i])) 464244971Sjkim { 465244971Sjkim /* This is a normal character */ 466244971Sjkim 467244971Sjkim AcpiOsPrintf ("%c", (int) String[i]); 468244971Sjkim } 469244971Sjkim else 470244971Sjkim { 471244971Sjkim /* All others will be Hex escapes */ 472244971Sjkim 473244971Sjkim AcpiOsPrintf ("\\x%2.2X", (INT32) String[i]); 474244971Sjkim } 475244971Sjkim break; 476244971Sjkim } 477244971Sjkim } 478244971Sjkim AcpiOsPrintf ("\""); 479244971Sjkim 480244971Sjkim if (i == MaxLength && String[i]) 481244971Sjkim { 482244971Sjkim AcpiOsPrintf ("..."); 483244971Sjkim } 484244971Sjkim} 485244971Sjkim 486244971Sjkim 487244971Sjkim/******************************************************************************* 488244971Sjkim * 489244971Sjkim * FUNCTION: AcpiUtValidAcpiChar 490244971Sjkim * 491244971Sjkim * PARAMETERS: Char - The character to be examined 492244971Sjkim * Position - Byte position (0-3) 493244971Sjkim * 494244971Sjkim * RETURN: TRUE if the character is valid, FALSE otherwise 495244971Sjkim * 496244971Sjkim * DESCRIPTION: Check for a valid ACPI character. Must be one of: 497244971Sjkim * 1) Upper case alpha 498244971Sjkim * 2) numeric 499244971Sjkim * 3) underscore 500244971Sjkim * 501244971Sjkim * We allow a '!' as the last character because of the ASF! table 502244971Sjkim * 503244971Sjkim ******************************************************************************/ 504244971Sjkim 505244971SjkimBOOLEAN 506244971SjkimAcpiUtValidAcpiChar ( 507244971Sjkim char Character, 508244971Sjkim UINT32 Position) 509244971Sjkim{ 510244971Sjkim 511244971Sjkim if (!((Character >= 'A' && Character <= 'Z') || 512244971Sjkim (Character >= '0' && Character <= '9') || 513244971Sjkim (Character == '_'))) 514244971Sjkim { 515244971Sjkim /* Allow a '!' in the last position */ 516244971Sjkim 517244971Sjkim if (Character == '!' && Position == 3) 518244971Sjkim { 519244971Sjkim return (TRUE); 520244971Sjkim } 521244971Sjkim 522244971Sjkim return (FALSE); 523244971Sjkim } 524244971Sjkim 525244971Sjkim return (TRUE); 526244971Sjkim} 527244971Sjkim 528244971Sjkim 529244971Sjkim/******************************************************************************* 530244971Sjkim * 531244971Sjkim * FUNCTION: AcpiUtValidAcpiName 532244971Sjkim * 533244971Sjkim * PARAMETERS: Name - The name to be examined 534244971Sjkim * 535244971Sjkim * RETURN: TRUE if the name is valid, FALSE otherwise 536244971Sjkim * 537244971Sjkim * DESCRIPTION: Check for a valid ACPI name. Each character must be one of: 538244971Sjkim * 1) Upper case alpha 539244971Sjkim * 2) numeric 540244971Sjkim * 3) underscore 541244971Sjkim * 542244971Sjkim ******************************************************************************/ 543244971Sjkim 544244971SjkimBOOLEAN 545244971SjkimAcpiUtValidAcpiName ( 546244971Sjkim UINT32 Name) 547244971Sjkim{ 548244971Sjkim UINT32 i; 549244971Sjkim 550244971Sjkim 551244971Sjkim ACPI_FUNCTION_ENTRY (); 552244971Sjkim 553244971Sjkim 554244971Sjkim for (i = 0; i < ACPI_NAME_SIZE; i++) 555244971Sjkim { 556244971Sjkim if (!AcpiUtValidAcpiChar ((ACPI_CAST_PTR (char, &Name))[i], i)) 557244971Sjkim { 558244971Sjkim return (FALSE); 559244971Sjkim } 560244971Sjkim } 561244971Sjkim 562244971Sjkim return (TRUE); 563244971Sjkim} 564244971Sjkim 565244971Sjkim 566244971Sjkim/******************************************************************************* 567244971Sjkim * 568244971Sjkim * FUNCTION: AcpiUtRepairName 569244971Sjkim * 570244971Sjkim * PARAMETERS: Name - The ACPI name to be repaired 571244971Sjkim * 572244971Sjkim * RETURN: Repaired version of the name 573244971Sjkim * 574244971Sjkim * DESCRIPTION: Repair an ACPI name: Change invalid characters to '*' and 575244971Sjkim * return the new name. NOTE: the Name parameter must reside in 576244971Sjkim * read/write memory, cannot be a const. 577244971Sjkim * 578244971Sjkim * An ACPI Name must consist of valid ACPI characters. We will repair the name 579244971Sjkim * if necessary because we don't want to abort because of this, but we want 580244971Sjkim * all namespace names to be printable. A warning message is appropriate. 581244971Sjkim * 582244971Sjkim * This issue came up because there are in fact machines that exhibit 583244971Sjkim * this problem, and we want to be able to enable ACPI support for them, 584244971Sjkim * even though there are a few bad names. 585244971Sjkim * 586244971Sjkim ******************************************************************************/ 587244971Sjkim 588244971Sjkimvoid 589244971SjkimAcpiUtRepairName ( 590244971Sjkim char *Name) 591244971Sjkim{ 592244971Sjkim UINT32 i; 593244971Sjkim BOOLEAN FoundBadChar = FALSE; 594244971Sjkim UINT32 OriginalName; 595244971Sjkim 596244971Sjkim 597244971Sjkim ACPI_FUNCTION_NAME (UtRepairName); 598244971Sjkim 599244971Sjkim 600244971Sjkim ACPI_MOVE_NAME (&OriginalName, Name); 601244971Sjkim 602244971Sjkim /* Check each character in the name */ 603244971Sjkim 604244971Sjkim for (i = 0; i < ACPI_NAME_SIZE; i++) 605244971Sjkim { 606244971Sjkim if (AcpiUtValidAcpiChar (Name[i], i)) 607244971Sjkim { 608244971Sjkim continue; 609244971Sjkim } 610244971Sjkim 611244971Sjkim /* 612244971Sjkim * Replace a bad character with something printable, yet technically 613244971Sjkim * still invalid. This prevents any collisions with existing "good" 614244971Sjkim * names in the namespace. 615244971Sjkim */ 616244971Sjkim Name[i] = '*'; 617244971Sjkim FoundBadChar = TRUE; 618244971Sjkim } 619244971Sjkim 620244971Sjkim if (FoundBadChar) 621244971Sjkim { 622244971Sjkim /* Report warning only if in strict mode or debug mode */ 623244971Sjkim 624244971Sjkim if (!AcpiGbl_EnableInterpreterSlack) 625244971Sjkim { 626244971Sjkim ACPI_WARNING ((AE_INFO, 627244971Sjkim "Invalid character(s) in name (0x%.8X), repaired: [%4.4s]", 628244971Sjkim OriginalName, Name)); 629244971Sjkim } 630244971Sjkim else 631244971Sjkim { 632244971Sjkim ACPI_DEBUG_PRINT ((ACPI_DB_INFO, 633244971Sjkim "Invalid character(s) in name (0x%.8X), repaired: [%4.4s]", 634244971Sjkim OriginalName, Name)); 635244971Sjkim } 636244971Sjkim } 637244971Sjkim} 638244971Sjkim 639244971Sjkim 640244971Sjkim#if defined ACPI_ASL_COMPILER || defined ACPI_EXEC_APP 641244971Sjkim/******************************************************************************* 642244971Sjkim * 643244971Sjkim * FUNCTION: UtConvertBackslashes 644244971Sjkim * 645244971Sjkim * PARAMETERS: Pathname - File pathname string to be converted 646244971Sjkim * 647244971Sjkim * RETURN: Modifies the input Pathname 648244971Sjkim * 649244971Sjkim * DESCRIPTION: Convert all backslashes (0x5C) to forward slashes (0x2F) within 650244971Sjkim * the entire input file pathname string. 651244971Sjkim * 652244971Sjkim ******************************************************************************/ 653244971Sjkim 654244971Sjkimvoid 655244971SjkimUtConvertBackslashes ( 656244971Sjkim char *Pathname) 657244971Sjkim{ 658244971Sjkim 659244971Sjkim if (!Pathname) 660244971Sjkim { 661244971Sjkim return; 662244971Sjkim } 663244971Sjkim 664244971Sjkim while (*Pathname) 665244971Sjkim { 666244971Sjkim if (*Pathname == '\\') 667244971Sjkim { 668244971Sjkim *Pathname = '/'; 669244971Sjkim } 670244971Sjkim 671244971Sjkim Pathname++; 672244971Sjkim } 673244971Sjkim} 674244971Sjkim#endif 675