utstring.c revision 250838
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: 223250838Sjkim 224244971Sjkim break; 225244971Sjkim 226244971Sjkim default: 227250838Sjkim 228244971Sjkim /* Invalid Base */ 229250838Sjkim 230244971Sjkim return_ACPI_STATUS (AE_BAD_PARAMETER); 231244971Sjkim } 232244971Sjkim 233244971Sjkim if (!String) 234244971Sjkim { 235244971Sjkim goto ErrorExit; 236244971Sjkim } 237244971Sjkim 238244971Sjkim /* Skip over any white space in the buffer */ 239244971Sjkim 240244971Sjkim while ((*String) && (ACPI_IS_SPACE (*String) || *String == '\t')) 241244971Sjkim { 242244971Sjkim String++; 243244971Sjkim } 244244971Sjkim 245244971Sjkim if (ToIntegerOp) 246244971Sjkim { 247244971Sjkim /* 248244971Sjkim * Base equal to ACPI_ANY_BASE means 'ToInteger operation case'. 249244971Sjkim * We need to determine if it is decimal or hexadecimal. 250244971Sjkim */ 251244971Sjkim if ((*String == '0') && (ACPI_TOLOWER (*(String + 1)) == 'x')) 252244971Sjkim { 253244971Sjkim SignOf0x = 1; 254244971Sjkim Base = 16; 255244971Sjkim 256244971Sjkim /* Skip over the leading '0x' */ 257244971Sjkim String += 2; 258244971Sjkim } 259244971Sjkim else 260244971Sjkim { 261244971Sjkim Base = 10; 262244971Sjkim } 263244971Sjkim } 264244971Sjkim 265244971Sjkim /* Any string left? Check that '0x' is not followed by white space. */ 266244971Sjkim 267244971Sjkim if (!(*String) || ACPI_IS_SPACE (*String) || *String == '\t') 268244971Sjkim { 269244971Sjkim if (ToIntegerOp) 270244971Sjkim { 271244971Sjkim goto ErrorExit; 272244971Sjkim } 273244971Sjkim else 274244971Sjkim { 275244971Sjkim goto AllDone; 276244971Sjkim } 277244971Sjkim } 278244971Sjkim 279244971Sjkim /* 280244971Sjkim * Perform a 32-bit or 64-bit conversion, depending upon the current 281244971Sjkim * execution mode of the interpreter 282244971Sjkim */ 283244971Sjkim Dividend = (Mode32) ? ACPI_UINT32_MAX : ACPI_UINT64_MAX; 284244971Sjkim 285244971Sjkim /* Main loop: convert the string to a 32- or 64-bit integer */ 286244971Sjkim 287244971Sjkim while (*String) 288244971Sjkim { 289244971Sjkim if (ACPI_IS_DIGIT (*String)) 290244971Sjkim { 291244971Sjkim /* Convert ASCII 0-9 to Decimal value */ 292244971Sjkim 293244971Sjkim ThisDigit = ((UINT8) *String) - '0'; 294244971Sjkim } 295244971Sjkim else if (Base == 10) 296244971Sjkim { 297244971Sjkim /* Digit is out of range; possible in ToInteger case only */ 298244971Sjkim 299244971Sjkim Term = 1; 300244971Sjkim } 301244971Sjkim else 302244971Sjkim { 303244971Sjkim ThisDigit = (UINT8) ACPI_TOUPPER (*String); 304244971Sjkim if (ACPI_IS_XDIGIT ((char) ThisDigit)) 305244971Sjkim { 306244971Sjkim /* Convert ASCII Hex char to value */ 307244971Sjkim 308244971Sjkim ThisDigit = ThisDigit - 'A' + 10; 309244971Sjkim } 310244971Sjkim else 311244971Sjkim { 312244971Sjkim Term = 1; 313244971Sjkim } 314244971Sjkim } 315244971Sjkim 316244971Sjkim if (Term) 317244971Sjkim { 318244971Sjkim if (ToIntegerOp) 319244971Sjkim { 320244971Sjkim goto ErrorExit; 321244971Sjkim } 322244971Sjkim else 323244971Sjkim { 324244971Sjkim break; 325244971Sjkim } 326244971Sjkim } 327244971Sjkim else if ((ValidDigits == 0) && (ThisDigit == 0) && !SignOf0x) 328244971Sjkim { 329244971Sjkim /* Skip zeros */ 330244971Sjkim String++; 331244971Sjkim continue; 332244971Sjkim } 333244971Sjkim 334244971Sjkim ValidDigits++; 335244971Sjkim 336244971Sjkim if (SignOf0x && ((ValidDigits > 16) || ((ValidDigits > 8) && Mode32))) 337244971Sjkim { 338244971Sjkim /* 339244971Sjkim * This is ToInteger operation case. 340244971Sjkim * No any restrictions for string-to-integer conversion, 341244971Sjkim * see ACPI spec. 342244971Sjkim */ 343244971Sjkim goto ErrorExit; 344244971Sjkim } 345244971Sjkim 346244971Sjkim /* Divide the digit into the correct position */ 347244971Sjkim 348244971Sjkim (void) AcpiUtShortDivide ((Dividend - (UINT64) ThisDigit), 349244971Sjkim Base, &Quotient, NULL); 350244971Sjkim 351244971Sjkim if (ReturnValue > Quotient) 352244971Sjkim { 353244971Sjkim if (ToIntegerOp) 354244971Sjkim { 355244971Sjkim goto ErrorExit; 356244971Sjkim } 357244971Sjkim else 358244971Sjkim { 359244971Sjkim break; 360244971Sjkim } 361244971Sjkim } 362244971Sjkim 363244971Sjkim ReturnValue *= Base; 364244971Sjkim ReturnValue += ThisDigit; 365244971Sjkim String++; 366244971Sjkim } 367244971Sjkim 368244971Sjkim /* All done, normal exit */ 369244971Sjkim 370244971SjkimAllDone: 371244971Sjkim 372244971Sjkim ACPI_DEBUG_PRINT ((ACPI_DB_EXEC, "Converted value: %8.8X%8.8X\n", 373244971Sjkim ACPI_FORMAT_UINT64 (ReturnValue))); 374244971Sjkim 375244971Sjkim *RetInteger = ReturnValue; 376244971Sjkim return_ACPI_STATUS (AE_OK); 377244971Sjkim 378244971Sjkim 379244971SjkimErrorExit: 380244971Sjkim /* Base was set/validated above */ 381244971Sjkim 382244971Sjkim if (Base == 10) 383244971Sjkim { 384244971Sjkim return_ACPI_STATUS (AE_BAD_DECIMAL_CONSTANT); 385244971Sjkim } 386244971Sjkim else 387244971Sjkim { 388244971Sjkim return_ACPI_STATUS (AE_BAD_HEX_CONSTANT); 389244971Sjkim } 390244971Sjkim} 391244971Sjkim 392244971Sjkim 393244971Sjkim/******************************************************************************* 394244971Sjkim * 395244971Sjkim * FUNCTION: AcpiUtPrintString 396244971Sjkim * 397244971Sjkim * PARAMETERS: String - Null terminated ASCII string 398244971Sjkim * MaxLength - Maximum output length 399244971Sjkim * 400244971Sjkim * RETURN: None 401244971Sjkim * 402244971Sjkim * DESCRIPTION: Dump an ASCII string with support for ACPI-defined escape 403244971Sjkim * sequences. 404244971Sjkim * 405244971Sjkim ******************************************************************************/ 406244971Sjkim 407244971Sjkimvoid 408244971SjkimAcpiUtPrintString ( 409244971Sjkim char *String, 410244971Sjkim UINT8 MaxLength) 411244971Sjkim{ 412244971Sjkim UINT32 i; 413244971Sjkim 414244971Sjkim 415244971Sjkim if (!String) 416244971Sjkim { 417244971Sjkim AcpiOsPrintf ("<\"NULL STRING PTR\">"); 418244971Sjkim return; 419244971Sjkim } 420244971Sjkim 421244971Sjkim AcpiOsPrintf ("\""); 422244971Sjkim for (i = 0; String[i] && (i < MaxLength); i++) 423244971Sjkim { 424244971Sjkim /* Escape sequences */ 425244971Sjkim 426244971Sjkim switch (String[i]) 427244971Sjkim { 428244971Sjkim case 0x07: 429250838Sjkim 430244971Sjkim AcpiOsPrintf ("\\a"); /* BELL */ 431244971Sjkim break; 432244971Sjkim 433244971Sjkim case 0x08: 434250838Sjkim 435244971Sjkim AcpiOsPrintf ("\\b"); /* BACKSPACE */ 436244971Sjkim break; 437244971Sjkim 438244971Sjkim case 0x0C: 439250838Sjkim 440244971Sjkim AcpiOsPrintf ("\\f"); /* FORMFEED */ 441244971Sjkim break; 442244971Sjkim 443244971Sjkim case 0x0A: 444250838Sjkim 445244971Sjkim AcpiOsPrintf ("\\n"); /* LINEFEED */ 446244971Sjkim break; 447244971Sjkim 448244971Sjkim case 0x0D: 449250838Sjkim 450244971Sjkim AcpiOsPrintf ("\\r"); /* CARRIAGE RETURN*/ 451244971Sjkim break; 452244971Sjkim 453244971Sjkim case 0x09: 454250838Sjkim 455244971Sjkim AcpiOsPrintf ("\\t"); /* HORIZONTAL TAB */ 456244971Sjkim break; 457244971Sjkim 458244971Sjkim case 0x0B: 459250838Sjkim 460244971Sjkim AcpiOsPrintf ("\\v"); /* VERTICAL TAB */ 461244971Sjkim break; 462244971Sjkim 463244971Sjkim case '\'': /* Single Quote */ 464244971Sjkim case '\"': /* Double Quote */ 465244971Sjkim case '\\': /* Backslash */ 466250838Sjkim 467244971Sjkim AcpiOsPrintf ("\\%c", (int) String[i]); 468244971Sjkim break; 469244971Sjkim 470244971Sjkim default: 471244971Sjkim 472244971Sjkim /* Check for printable character or hex escape */ 473244971Sjkim 474244971Sjkim if (ACPI_IS_PRINT (String[i])) 475244971Sjkim { 476244971Sjkim /* This is a normal character */ 477244971Sjkim 478244971Sjkim AcpiOsPrintf ("%c", (int) String[i]); 479244971Sjkim } 480244971Sjkim else 481244971Sjkim { 482244971Sjkim /* All others will be Hex escapes */ 483244971Sjkim 484244971Sjkim AcpiOsPrintf ("\\x%2.2X", (INT32) String[i]); 485244971Sjkim } 486244971Sjkim break; 487244971Sjkim } 488244971Sjkim } 489244971Sjkim AcpiOsPrintf ("\""); 490244971Sjkim 491244971Sjkim if (i == MaxLength && String[i]) 492244971Sjkim { 493244971Sjkim AcpiOsPrintf ("..."); 494244971Sjkim } 495244971Sjkim} 496244971Sjkim 497244971Sjkim 498244971Sjkim/******************************************************************************* 499244971Sjkim * 500244971Sjkim * FUNCTION: AcpiUtValidAcpiChar 501244971Sjkim * 502244971Sjkim * PARAMETERS: Char - The character to be examined 503244971Sjkim * Position - Byte position (0-3) 504244971Sjkim * 505244971Sjkim * RETURN: TRUE if the character is valid, FALSE otherwise 506244971Sjkim * 507244971Sjkim * DESCRIPTION: Check for a valid ACPI character. Must be one of: 508244971Sjkim * 1) Upper case alpha 509244971Sjkim * 2) numeric 510244971Sjkim * 3) underscore 511244971Sjkim * 512244971Sjkim * We allow a '!' as the last character because of the ASF! table 513244971Sjkim * 514244971Sjkim ******************************************************************************/ 515244971Sjkim 516244971SjkimBOOLEAN 517244971SjkimAcpiUtValidAcpiChar ( 518244971Sjkim char Character, 519244971Sjkim UINT32 Position) 520244971Sjkim{ 521244971Sjkim 522244971Sjkim if (!((Character >= 'A' && Character <= 'Z') || 523244971Sjkim (Character >= '0' && Character <= '9') || 524244971Sjkim (Character == '_'))) 525244971Sjkim { 526244971Sjkim /* Allow a '!' in the last position */ 527244971Sjkim 528244971Sjkim if (Character == '!' && Position == 3) 529244971Sjkim { 530244971Sjkim return (TRUE); 531244971Sjkim } 532244971Sjkim 533244971Sjkim return (FALSE); 534244971Sjkim } 535244971Sjkim 536244971Sjkim return (TRUE); 537244971Sjkim} 538244971Sjkim 539244971Sjkim 540244971Sjkim/******************************************************************************* 541244971Sjkim * 542244971Sjkim * FUNCTION: AcpiUtValidAcpiName 543244971Sjkim * 544250838Sjkim * PARAMETERS: Name - The name to be examined. Does not have to 545250838Sjkim * be NULL terminated string. 546244971Sjkim * 547244971Sjkim * RETURN: TRUE if the name is valid, FALSE otherwise 548244971Sjkim * 549244971Sjkim * DESCRIPTION: Check for a valid ACPI name. Each character must be one of: 550244971Sjkim * 1) Upper case alpha 551244971Sjkim * 2) numeric 552244971Sjkim * 3) underscore 553244971Sjkim * 554244971Sjkim ******************************************************************************/ 555244971Sjkim 556244971SjkimBOOLEAN 557244971SjkimAcpiUtValidAcpiName ( 558250838Sjkim char *Name) 559244971Sjkim{ 560244971Sjkim UINT32 i; 561244971Sjkim 562244971Sjkim 563244971Sjkim ACPI_FUNCTION_ENTRY (); 564244971Sjkim 565244971Sjkim 566244971Sjkim for (i = 0; i < ACPI_NAME_SIZE; i++) 567244971Sjkim { 568250838Sjkim if (!AcpiUtValidAcpiChar (Name[i], i)) 569244971Sjkim { 570244971Sjkim return (FALSE); 571244971Sjkim } 572244971Sjkim } 573244971Sjkim 574244971Sjkim return (TRUE); 575244971Sjkim} 576244971Sjkim 577244971Sjkim 578244971Sjkim/******************************************************************************* 579244971Sjkim * 580244971Sjkim * FUNCTION: AcpiUtRepairName 581244971Sjkim * 582244971Sjkim * PARAMETERS: Name - The ACPI name to be repaired 583244971Sjkim * 584244971Sjkim * RETURN: Repaired version of the name 585244971Sjkim * 586244971Sjkim * DESCRIPTION: Repair an ACPI name: Change invalid characters to '*' and 587244971Sjkim * return the new name. NOTE: the Name parameter must reside in 588244971Sjkim * read/write memory, cannot be a const. 589244971Sjkim * 590244971Sjkim * An ACPI Name must consist of valid ACPI characters. We will repair the name 591244971Sjkim * if necessary because we don't want to abort because of this, but we want 592244971Sjkim * all namespace names to be printable. A warning message is appropriate. 593244971Sjkim * 594244971Sjkim * This issue came up because there are in fact machines that exhibit 595244971Sjkim * this problem, and we want to be able to enable ACPI support for them, 596244971Sjkim * even though there are a few bad names. 597244971Sjkim * 598244971Sjkim ******************************************************************************/ 599244971Sjkim 600244971Sjkimvoid 601244971SjkimAcpiUtRepairName ( 602244971Sjkim char *Name) 603244971Sjkim{ 604244971Sjkim UINT32 i; 605244971Sjkim BOOLEAN FoundBadChar = FALSE; 606244971Sjkim UINT32 OriginalName; 607244971Sjkim 608244971Sjkim 609244971Sjkim ACPI_FUNCTION_NAME (UtRepairName); 610244971Sjkim 611244971Sjkim 612244971Sjkim ACPI_MOVE_NAME (&OriginalName, Name); 613244971Sjkim 614244971Sjkim /* Check each character in the name */ 615244971Sjkim 616244971Sjkim for (i = 0; i < ACPI_NAME_SIZE; i++) 617244971Sjkim { 618244971Sjkim if (AcpiUtValidAcpiChar (Name[i], i)) 619244971Sjkim { 620244971Sjkim continue; 621244971Sjkim } 622244971Sjkim 623244971Sjkim /* 624244971Sjkim * Replace a bad character with something printable, yet technically 625244971Sjkim * still invalid. This prevents any collisions with existing "good" 626244971Sjkim * names in the namespace. 627244971Sjkim */ 628244971Sjkim Name[i] = '*'; 629244971Sjkim FoundBadChar = TRUE; 630244971Sjkim } 631244971Sjkim 632244971Sjkim if (FoundBadChar) 633244971Sjkim { 634244971Sjkim /* Report warning only if in strict mode or debug mode */ 635244971Sjkim 636244971Sjkim if (!AcpiGbl_EnableInterpreterSlack) 637244971Sjkim { 638244971Sjkim ACPI_WARNING ((AE_INFO, 639244971Sjkim "Invalid character(s) in name (0x%.8X), repaired: [%4.4s]", 640244971Sjkim OriginalName, Name)); 641244971Sjkim } 642244971Sjkim else 643244971Sjkim { 644244971Sjkim ACPI_DEBUG_PRINT ((ACPI_DB_INFO, 645244971Sjkim "Invalid character(s) in name (0x%.8X), repaired: [%4.4s]", 646244971Sjkim OriginalName, Name)); 647244971Sjkim } 648244971Sjkim } 649244971Sjkim} 650244971Sjkim 651244971Sjkim 652244971Sjkim#if defined ACPI_ASL_COMPILER || defined ACPI_EXEC_APP 653244971Sjkim/******************************************************************************* 654244971Sjkim * 655244971Sjkim * FUNCTION: UtConvertBackslashes 656244971Sjkim * 657244971Sjkim * PARAMETERS: Pathname - File pathname string to be converted 658244971Sjkim * 659244971Sjkim * RETURN: Modifies the input Pathname 660244971Sjkim * 661244971Sjkim * DESCRIPTION: Convert all backslashes (0x5C) to forward slashes (0x2F) within 662244971Sjkim * the entire input file pathname string. 663244971Sjkim * 664244971Sjkim ******************************************************************************/ 665244971Sjkim 666244971Sjkimvoid 667244971SjkimUtConvertBackslashes ( 668244971Sjkim char *Pathname) 669244971Sjkim{ 670244971Sjkim 671244971Sjkim if (!Pathname) 672244971Sjkim { 673244971Sjkim return; 674244971Sjkim } 675244971Sjkim 676244971Sjkim while (*Pathname) 677244971Sjkim { 678244971Sjkim if (*Pathname == '\\') 679244971Sjkim { 680244971Sjkim *Pathname = '/'; 681244971Sjkim } 682244971Sjkim 683244971Sjkim Pathname++; 684244971Sjkim } 685244971Sjkim} 686244971Sjkim#endif 687