675 lines
17 KiB
C
675 lines
17 KiB
C
/*******************************************************************************
|
|
*
|
|
* Module Name: utstring - Common functions for strings and characters
|
|
*
|
|
******************************************************************************/
|
|
|
|
/*
|
|
* Copyright (C) 2000 - 2013, Intel Corp.
|
|
* All rights reserved.
|
|
*
|
|
* Redistribution and use in source and binary forms, with or without
|
|
* modification, are permitted provided that the following conditions
|
|
* are met:
|
|
* 1. Redistributions of source code must retain the above copyright
|
|
* notice, this list of conditions, and the following disclaimer,
|
|
* without modification.
|
|
* 2. Redistributions in binary form must reproduce at minimum a disclaimer
|
|
* substantially similar to the "NO WARRANTY" disclaimer below
|
|
* ("Disclaimer") and any redistribution must be conditioned upon
|
|
* including a substantially similar Disclaimer requirement for further
|
|
* binary redistribution.
|
|
* 3. Neither the names of the above-listed copyright holders nor the names
|
|
* of any contributors may be used to endorse or promote products derived
|
|
* from this software without specific prior written permission.
|
|
*
|
|
* Alternatively, this software may be distributed under the terms of the
|
|
* GNU General Public License ("GPL") version 2 as published by the Free
|
|
* Software Foundation.
|
|
*
|
|
* NO WARRANTY
|
|
* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
|
|
* "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
|
|
* LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTIBILITY AND FITNESS FOR
|
|
* A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
|
|
* HOLDERS OR CONTRIBUTORS BE LIABLE FOR SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
|
|
* DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
|
|
* OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
|
|
* HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT,
|
|
* STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING
|
|
* IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
|
|
* POSSIBILITY OF SUCH DAMAGES.
|
|
*/
|
|
|
|
|
|
#define __UTSTRING_C__
|
|
|
|
#include "acpi.h"
|
|
#include "accommon.h"
|
|
#include "acnamesp.h"
|
|
|
|
|
|
#define _COMPONENT ACPI_UTILITIES
|
|
ACPI_MODULE_NAME ("utstring")
|
|
|
|
|
|
/*
|
|
* Non-ANSI C library functions - strlwr, strupr, stricmp, and a 64-bit
|
|
* version of strtoul.
|
|
*/
|
|
|
|
#ifdef ACPI_ASL_COMPILER
|
|
/*******************************************************************************
|
|
*
|
|
* FUNCTION: AcpiUtStrlwr (strlwr)
|
|
*
|
|
* PARAMETERS: SrcString - The source string to convert
|
|
*
|
|
* RETURN: None
|
|
*
|
|
* DESCRIPTION: Convert string to lowercase
|
|
*
|
|
* NOTE: This is not a POSIX function, so it appears here, not in utclib.c
|
|
*
|
|
******************************************************************************/
|
|
|
|
void
|
|
AcpiUtStrlwr (
|
|
char *SrcString)
|
|
{
|
|
char *String;
|
|
|
|
|
|
ACPI_FUNCTION_ENTRY ();
|
|
|
|
|
|
if (!SrcString)
|
|
{
|
|
return;
|
|
}
|
|
|
|
/* Walk entire string, lowercasing the letters */
|
|
|
|
for (String = SrcString; *String; String++)
|
|
{
|
|
*String = (char) ACPI_TOLOWER (*String);
|
|
}
|
|
|
|
return;
|
|
}
|
|
|
|
|
|
/******************************************************************************
|
|
*
|
|
* FUNCTION: AcpiUtStricmp (stricmp)
|
|
*
|
|
* PARAMETERS: String1 - first string to compare
|
|
* String2 - second string to compare
|
|
*
|
|
* RETURN: int that signifies string relationship. Zero means strings
|
|
* are equal.
|
|
*
|
|
* DESCRIPTION: Implementation of the non-ANSI stricmp function (compare
|
|
* strings with no case sensitivity)
|
|
*
|
|
******************************************************************************/
|
|
|
|
int
|
|
AcpiUtStricmp (
|
|
char *String1,
|
|
char *String2)
|
|
{
|
|
int c1;
|
|
int c2;
|
|
|
|
|
|
do
|
|
{
|
|
c1 = tolower ((int) *String1);
|
|
c2 = tolower ((int) *String2);
|
|
|
|
String1++;
|
|
String2++;
|
|
}
|
|
while ((c1 == c2) && (c1));
|
|
|
|
return (c1 - c2);
|
|
}
|
|
#endif
|
|
|
|
|
|
/*******************************************************************************
|
|
*
|
|
* FUNCTION: AcpiUtStrupr (strupr)
|
|
*
|
|
* PARAMETERS: SrcString - The source string to convert
|
|
*
|
|
* RETURN: None
|
|
*
|
|
* DESCRIPTION: Convert string to uppercase
|
|
*
|
|
* NOTE: This is not a POSIX function, so it appears here, not in utclib.c
|
|
*
|
|
******************************************************************************/
|
|
|
|
void
|
|
AcpiUtStrupr (
|
|
char *SrcString)
|
|
{
|
|
char *String;
|
|
|
|
|
|
ACPI_FUNCTION_ENTRY ();
|
|
|
|
|
|
if (!SrcString)
|
|
{
|
|
return;
|
|
}
|
|
|
|
/* Walk entire string, uppercasing the letters */
|
|
|
|
for (String = SrcString; *String; String++)
|
|
{
|
|
*String = (char) ACPI_TOUPPER (*String);
|
|
}
|
|
|
|
return;
|
|
}
|
|
|
|
|
|
/*******************************************************************************
|
|
*
|
|
* FUNCTION: AcpiUtStrtoul64
|
|
*
|
|
* PARAMETERS: String - Null terminated string
|
|
* Base - Radix of the string: 16 or ACPI_ANY_BASE;
|
|
* ACPI_ANY_BASE means 'in behalf of ToInteger'
|
|
* RetInteger - Where the converted integer is returned
|
|
*
|
|
* RETURN: Status and Converted value
|
|
*
|
|
* DESCRIPTION: Convert a string into an unsigned value. Performs either a
|
|
* 32-bit or 64-bit conversion, depending on the current mode
|
|
* of the interpreter.
|
|
* NOTE: Does not support Octal strings, not needed.
|
|
*
|
|
******************************************************************************/
|
|
|
|
ACPI_STATUS
|
|
AcpiUtStrtoul64 (
|
|
char *String,
|
|
UINT32 Base,
|
|
UINT64 *RetInteger)
|
|
{
|
|
UINT32 ThisDigit = 0;
|
|
UINT64 ReturnValue = 0;
|
|
UINT64 Quotient;
|
|
UINT64 Dividend;
|
|
UINT32 ToIntegerOp = (Base == ACPI_ANY_BASE);
|
|
UINT32 Mode32 = (AcpiGbl_IntegerByteWidth == 4);
|
|
UINT8 ValidDigits = 0;
|
|
UINT8 SignOf0x = 0;
|
|
UINT8 Term = 0;
|
|
|
|
|
|
ACPI_FUNCTION_TRACE_STR (UtStroul64, String);
|
|
|
|
|
|
switch (Base)
|
|
{
|
|
case ACPI_ANY_BASE:
|
|
case 16:
|
|
break;
|
|
|
|
default:
|
|
/* Invalid Base */
|
|
return_ACPI_STATUS (AE_BAD_PARAMETER);
|
|
}
|
|
|
|
if (!String)
|
|
{
|
|
goto ErrorExit;
|
|
}
|
|
|
|
/* Skip over any white space in the buffer */
|
|
|
|
while ((*String) && (ACPI_IS_SPACE (*String) || *String == '\t'))
|
|
{
|
|
String++;
|
|
}
|
|
|
|
if (ToIntegerOp)
|
|
{
|
|
/*
|
|
* Base equal to ACPI_ANY_BASE means 'ToInteger operation case'.
|
|
* We need to determine if it is decimal or hexadecimal.
|
|
*/
|
|
if ((*String == '0') && (ACPI_TOLOWER (*(String + 1)) == 'x'))
|
|
{
|
|
SignOf0x = 1;
|
|
Base = 16;
|
|
|
|
/* Skip over the leading '0x' */
|
|
String += 2;
|
|
}
|
|
else
|
|
{
|
|
Base = 10;
|
|
}
|
|
}
|
|
|
|
/* Any string left? Check that '0x' is not followed by white space. */
|
|
|
|
if (!(*String) || ACPI_IS_SPACE (*String) || *String == '\t')
|
|
{
|
|
if (ToIntegerOp)
|
|
{
|
|
goto ErrorExit;
|
|
}
|
|
else
|
|
{
|
|
goto AllDone;
|
|
}
|
|
}
|
|
|
|
/*
|
|
* Perform a 32-bit or 64-bit conversion, depending upon the current
|
|
* execution mode of the interpreter
|
|
*/
|
|
Dividend = (Mode32) ? ACPI_UINT32_MAX : ACPI_UINT64_MAX;
|
|
|
|
/* Main loop: convert the string to a 32- or 64-bit integer */
|
|
|
|
while (*String)
|
|
{
|
|
if (ACPI_IS_DIGIT (*String))
|
|
{
|
|
/* Convert ASCII 0-9 to Decimal value */
|
|
|
|
ThisDigit = ((UINT8) *String) - '0';
|
|
}
|
|
else if (Base == 10)
|
|
{
|
|
/* Digit is out of range; possible in ToInteger case only */
|
|
|
|
Term = 1;
|
|
}
|
|
else
|
|
{
|
|
ThisDigit = (UINT8) ACPI_TOUPPER (*String);
|
|
if (ACPI_IS_XDIGIT ((char) ThisDigit))
|
|
{
|
|
/* Convert ASCII Hex char to value */
|
|
|
|
ThisDigit = ThisDigit - 'A' + 10;
|
|
}
|
|
else
|
|
{
|
|
Term = 1;
|
|
}
|
|
}
|
|
|
|
if (Term)
|
|
{
|
|
if (ToIntegerOp)
|
|
{
|
|
goto ErrorExit;
|
|
}
|
|
else
|
|
{
|
|
break;
|
|
}
|
|
}
|
|
else if ((ValidDigits == 0) && (ThisDigit == 0) && !SignOf0x)
|
|
{
|
|
/* Skip zeros */
|
|
String++;
|
|
continue;
|
|
}
|
|
|
|
ValidDigits++;
|
|
|
|
if (SignOf0x && ((ValidDigits > 16) || ((ValidDigits > 8) && Mode32)))
|
|
{
|
|
/*
|
|
* This is ToInteger operation case.
|
|
* No any restrictions for string-to-integer conversion,
|
|
* see ACPI spec.
|
|
*/
|
|
goto ErrorExit;
|
|
}
|
|
|
|
/* Divide the digit into the correct position */
|
|
|
|
(void) AcpiUtShortDivide ((Dividend - (UINT64) ThisDigit),
|
|
Base, &Quotient, NULL);
|
|
|
|
if (ReturnValue > Quotient)
|
|
{
|
|
if (ToIntegerOp)
|
|
{
|
|
goto ErrorExit;
|
|
}
|
|
else
|
|
{
|
|
break;
|
|
}
|
|
}
|
|
|
|
ReturnValue *= Base;
|
|
ReturnValue += ThisDigit;
|
|
String++;
|
|
}
|
|
|
|
/* All done, normal exit */
|
|
|
|
AllDone:
|
|
|
|
ACPI_DEBUG_PRINT ((ACPI_DB_EXEC, "Converted value: %8.8X%8.8X\n",
|
|
ACPI_FORMAT_UINT64 (ReturnValue)));
|
|
|
|
*RetInteger = ReturnValue;
|
|
return_ACPI_STATUS (AE_OK);
|
|
|
|
|
|
ErrorExit:
|
|
/* Base was set/validated above */
|
|
|
|
if (Base == 10)
|
|
{
|
|
return_ACPI_STATUS (AE_BAD_DECIMAL_CONSTANT);
|
|
}
|
|
else
|
|
{
|
|
return_ACPI_STATUS (AE_BAD_HEX_CONSTANT);
|
|
}
|
|
}
|
|
|
|
|
|
/*******************************************************************************
|
|
*
|
|
* FUNCTION: AcpiUtPrintString
|
|
*
|
|
* PARAMETERS: String - Null terminated ASCII string
|
|
* MaxLength - Maximum output length
|
|
*
|
|
* RETURN: None
|
|
*
|
|
* DESCRIPTION: Dump an ASCII string with support for ACPI-defined escape
|
|
* sequences.
|
|
*
|
|
******************************************************************************/
|
|
|
|
void
|
|
AcpiUtPrintString (
|
|
char *String,
|
|
UINT8 MaxLength)
|
|
{
|
|
UINT32 i;
|
|
|
|
|
|
if (!String)
|
|
{
|
|
AcpiOsPrintf ("<\"NULL STRING PTR\">");
|
|
return;
|
|
}
|
|
|
|
AcpiOsPrintf ("\"");
|
|
for (i = 0; String[i] && (i < MaxLength); i++)
|
|
{
|
|
/* Escape sequences */
|
|
|
|
switch (String[i])
|
|
{
|
|
case 0x07:
|
|
AcpiOsPrintf ("\\a"); /* BELL */
|
|
break;
|
|
|
|
case 0x08:
|
|
AcpiOsPrintf ("\\b"); /* BACKSPACE */
|
|
break;
|
|
|
|
case 0x0C:
|
|
AcpiOsPrintf ("\\f"); /* FORMFEED */
|
|
break;
|
|
|
|
case 0x0A:
|
|
AcpiOsPrintf ("\\n"); /* LINEFEED */
|
|
break;
|
|
|
|
case 0x0D:
|
|
AcpiOsPrintf ("\\r"); /* CARRIAGE RETURN*/
|
|
break;
|
|
|
|
case 0x09:
|
|
AcpiOsPrintf ("\\t"); /* HORIZONTAL TAB */
|
|
break;
|
|
|
|
case 0x0B:
|
|
AcpiOsPrintf ("\\v"); /* VERTICAL TAB */
|
|
break;
|
|
|
|
case '\'': /* Single Quote */
|
|
case '\"': /* Double Quote */
|
|
case '\\': /* Backslash */
|
|
AcpiOsPrintf ("\\%c", (int) String[i]);
|
|
break;
|
|
|
|
default:
|
|
|
|
/* Check for printable character or hex escape */
|
|
|
|
if (ACPI_IS_PRINT (String[i]))
|
|
{
|
|
/* This is a normal character */
|
|
|
|
AcpiOsPrintf ("%c", (int) String[i]);
|
|
}
|
|
else
|
|
{
|
|
/* All others will be Hex escapes */
|
|
|
|
AcpiOsPrintf ("\\x%2.2X", (INT32) String[i]);
|
|
}
|
|
break;
|
|
}
|
|
}
|
|
AcpiOsPrintf ("\"");
|
|
|
|
if (i == MaxLength && String[i])
|
|
{
|
|
AcpiOsPrintf ("...");
|
|
}
|
|
}
|
|
|
|
|
|
/*******************************************************************************
|
|
*
|
|
* FUNCTION: AcpiUtValidAcpiChar
|
|
*
|
|
* PARAMETERS: Char - The character to be examined
|
|
* Position - Byte position (0-3)
|
|
*
|
|
* RETURN: TRUE if the character is valid, FALSE otherwise
|
|
*
|
|
* DESCRIPTION: Check for a valid ACPI character. Must be one of:
|
|
* 1) Upper case alpha
|
|
* 2) numeric
|
|
* 3) underscore
|
|
*
|
|
* We allow a '!' as the last character because of the ASF! table
|
|
*
|
|
******************************************************************************/
|
|
|
|
BOOLEAN
|
|
AcpiUtValidAcpiChar (
|
|
char Character,
|
|
UINT32 Position)
|
|
{
|
|
|
|
if (!((Character >= 'A' && Character <= 'Z') ||
|
|
(Character >= '0' && Character <= '9') ||
|
|
(Character == '_')))
|
|
{
|
|
/* Allow a '!' in the last position */
|
|
|
|
if (Character == '!' && Position == 3)
|
|
{
|
|
return (TRUE);
|
|
}
|
|
|
|
return (FALSE);
|
|
}
|
|
|
|
return (TRUE);
|
|
}
|
|
|
|
|
|
/*******************************************************************************
|
|
*
|
|
* FUNCTION: AcpiUtValidAcpiName
|
|
*
|
|
* PARAMETERS: Name - The name to be examined
|
|
*
|
|
* RETURN: TRUE if the name is valid, FALSE otherwise
|
|
*
|
|
* DESCRIPTION: Check for a valid ACPI name. Each character must be one of:
|
|
* 1) Upper case alpha
|
|
* 2) numeric
|
|
* 3) underscore
|
|
*
|
|
******************************************************************************/
|
|
|
|
BOOLEAN
|
|
AcpiUtValidAcpiName (
|
|
UINT32 Name)
|
|
{
|
|
UINT32 i;
|
|
|
|
|
|
ACPI_FUNCTION_ENTRY ();
|
|
|
|
|
|
for (i = 0; i < ACPI_NAME_SIZE; i++)
|
|
{
|
|
if (!AcpiUtValidAcpiChar ((ACPI_CAST_PTR (char, &Name))[i], i))
|
|
{
|
|
return (FALSE);
|
|
}
|
|
}
|
|
|
|
return (TRUE);
|
|
}
|
|
|
|
|
|
/*******************************************************************************
|
|
*
|
|
* FUNCTION: AcpiUtRepairName
|
|
*
|
|
* PARAMETERS: Name - The ACPI name to be repaired
|
|
*
|
|
* RETURN: Repaired version of the name
|
|
*
|
|
* DESCRIPTION: Repair an ACPI name: Change invalid characters to '*' and
|
|
* return the new name. NOTE: the Name parameter must reside in
|
|
* read/write memory, cannot be a const.
|
|
*
|
|
* An ACPI Name must consist of valid ACPI characters. We will repair the name
|
|
* if necessary because we don't want to abort because of this, but we want
|
|
* all namespace names to be printable. A warning message is appropriate.
|
|
*
|
|
* This issue came up because there are in fact machines that exhibit
|
|
* this problem, and we want to be able to enable ACPI support for them,
|
|
* even though there are a few bad names.
|
|
*
|
|
******************************************************************************/
|
|
|
|
void
|
|
AcpiUtRepairName (
|
|
char *Name)
|
|
{
|
|
UINT32 i;
|
|
BOOLEAN FoundBadChar = FALSE;
|
|
UINT32 OriginalName;
|
|
|
|
|
|
ACPI_FUNCTION_NAME (UtRepairName);
|
|
|
|
|
|
ACPI_MOVE_NAME (&OriginalName, Name);
|
|
|
|
/* Check each character in the name */
|
|
|
|
for (i = 0; i < ACPI_NAME_SIZE; i++)
|
|
{
|
|
if (AcpiUtValidAcpiChar (Name[i], i))
|
|
{
|
|
continue;
|
|
}
|
|
|
|
/*
|
|
* Replace a bad character with something printable, yet technically
|
|
* still invalid. This prevents any collisions with existing "good"
|
|
* names in the namespace.
|
|
*/
|
|
Name[i] = '*';
|
|
FoundBadChar = TRUE;
|
|
}
|
|
|
|
if (FoundBadChar)
|
|
{
|
|
/* Report warning only if in strict mode or debug mode */
|
|
|
|
if (!AcpiGbl_EnableInterpreterSlack)
|
|
{
|
|
ACPI_WARNING ((AE_INFO,
|
|
"Invalid character(s) in name (0x%.8X), repaired: [%4.4s]",
|
|
OriginalName, Name));
|
|
}
|
|
else
|
|
{
|
|
ACPI_DEBUG_PRINT ((ACPI_DB_INFO,
|
|
"Invalid character(s) in name (0x%.8X), repaired: [%4.4s]",
|
|
OriginalName, Name));
|
|
}
|
|
}
|
|
}
|
|
|
|
|
|
#if defined ACPI_ASL_COMPILER || defined ACPI_EXEC_APP
|
|
/*******************************************************************************
|
|
*
|
|
* FUNCTION: UtConvertBackslashes
|
|
*
|
|
* PARAMETERS: Pathname - File pathname string to be converted
|
|
*
|
|
* RETURN: Modifies the input Pathname
|
|
*
|
|
* DESCRIPTION: Convert all backslashes (0x5C) to forward slashes (0x2F) within
|
|
* the entire input file pathname string.
|
|
*
|
|
******************************************************************************/
|
|
|
|
void
|
|
UtConvertBackslashes (
|
|
char *Pathname)
|
|
{
|
|
|
|
if (!Pathname)
|
|
{
|
|
return;
|
|
}
|
|
|
|
while (*Pathname)
|
|
{
|
|
if (*Pathname == '\\')
|
|
{
|
|
*Pathname = '/';
|
|
}
|
|
|
|
Pathname++;
|
|
}
|
|
}
|
|
#endif
|