From d9e5c1fffb22d39dd52ef23febe40cd4e2ee0965 Mon Sep 17 00:00:00 2001 From: qwang12 Date: Fri, 23 May 2008 05:25:44 +0000 Subject: 1) Add BufToHexString, HexStringToBuf and IsHexDigit to BaseLib. 2) Remove the duplicated functions implementation from the modules that reference these APIs git-svn-id: https://edk2.svn.sourceforge.net/svnroot/edk2/trunk/edk2@5282 6f19259b-4bc3-4df7-8a09-765794883524 --- MdePkg/Library/BaseLib/String.c | 239 +++++++++++++++++++++ MdePkg/Library/IfrSupportLib/IfrSupportLib.inf | 3 - MdePkg/Library/IfrSupportLib/UefiIfrForm.c | 63 +----- .../Library/IfrSupportLib/UefiIfrLibraryInternal.h | 4 - 4 files changed, 246 insertions(+), 63 deletions(-) (limited to 'MdePkg/Library') diff --git a/MdePkg/Library/BaseLib/String.c b/MdePkg/Library/BaseLib/String.c index 94471f3329..909262e587 100644 --- a/MdePkg/Library/BaseLib/String.c +++ b/MdePkg/Library/BaseLib/String.c @@ -2073,3 +2073,242 @@ BcdToDecimal8 ( } +/** + Convert a nibble in the low 4 bits of a byte to a Unicode hexadecimal character. + + This function converts a nibble in the low 4 bits of a byte to a Unicode hexadecimal + character For example, the nibble 0x01 and 0x0A will converted to L'1' and L'A' + respectively. + + The upper nibble in the input byte will be masked off. + + @param Nibble The nibble which is in the low 4 bits of the input byte. + + @retval CHAR16 The Unicode hexadecimal character. + +**/ +CHAR16 +NibbleToHexChar ( + IN UINT8 Nibble + ) +{ + Nibble &= 0x0F; + if (Nibble <= 0x9) { + return (CHAR16)(Nibble + L'0'); + } + + return (CHAR16)(Nibble - 0xA + L'A'); +} + +/** + Convert binary buffer to a Unicode String in a specified sequence. + + This function converts bytes in the binary Buffer Buf to a Unicode String Str. + Each byte will be represented by two Unicode characters. For example, byte 0xA1 will + be converted into two Unicode character L'A' and L'1'. In the output String, the Unicode Character + for the Most Significant Nibble will be put before the Unicode Character for the Least Significant + Nibble. The output string for the buffer containing a single byte 0xA1 will be L"A1". + For a buffer with multiple bytes, the Unicode character produced by the first byte will be put into the + the last character in the output string. The one next to first byte will be put into the + character before the last character. This rules applies to the rest of the bytes. The Unicode + character by the last byte will be put into the first character in the output string. For example, + the input buffer for a 64-bits unsigned integrer 0x12345678abcdef1234 will be converted to + a Unicode string equal to L"12345678abcdef1234". + + @param String On input, String is pointed to the buffer allocated for the convertion. + @param StringLen The Length of String buffer to hold the output String. The length must include the tailing '\0' character. + The StringLen required to convert a N bytes Buffer will be a least equal to or greater + than 2*N + 1. + @param Buffer The pointer to a input buffer. + @param BufferSizeInBytes Lenth in bytes of the input buffer. + + + @retval EFI_SUCCESS The convertion is successfull. All bytes in Buffer has been convert to the corresponding + Unicode character and placed into the right place in String. + @retval EFI_BUFFER_TOO_SMALL StringSizeInBytes is smaller than 2 * N + 1the number of bytes required to + complete the convertion. +**/ +RETURN_STATUS +EFIAPI +BufToHexString ( + IN OUT CHAR16 *String, + IN OUT UINTN *StringLen, + IN CONST UINT8 *Buffer, + IN UINTN BufferSizeInBytes + ) +{ + UINTN Idx; + UINT8 Byte; + UINTN StrLen; + + // + // Make sure string is either passed or allocate enough. + // It takes 2 Unicode characters (4 bytes) to represent 1 byte of the binary buffer. + // Plus the Unicode termination character. + // + StrLen = BufferSizeInBytes * 2; + if (StrLen > ((*StringLen) - 1)) { + *StringLen = StrLen + 1; + return RETURN_BUFFER_TOO_SMALL; + } + + *StringLen = StrLen + 1; + // + // Ends the string. + // + String[StrLen] = L'\0'; + + for (Idx = 0; Idx < BufferSizeInBytes; Idx++) { + + Byte = Buffer[Idx]; + String[StrLen - 1 - Idx * 2] = NibbleToHexChar (Byte); + String[StrLen - 2 - Idx * 2] = NibbleToHexChar ((UINT8)(Byte >> 4)); + } + + return RETURN_SUCCESS; +} + + +/** + Convert a Unicode string consisting of hexadecimal characters to a output byte buffer. + + This function converts a Unicode string consisting of characters in the range of Hexadecimal + character (L'0' to L'9', L'A' to L'F' and L'a' to L'f') to a output byte buffer. The function will stop + at the first non-hexadecimal character or the NULL character. The convertion process can be + simply viewed as the reverse operations defined by BufToHexString. Two Unicode characters will be + converted into one byte. The first Unicode character represents the Most Significant Nibble and the + second Unicode character represents the Least Significant Nibble in the output byte. + The first pair of Unicode characters represents the last byte in the output buffer. The second pair of Unicode + characters represent the the byte preceding the last byte. This rule applies to the rest pairs of bytes. + The last pair represent the first byte in the output buffer. + + For example, a Unciode String L"12345678" will be converted into a buffer wil the following bytes + (first byte is the byte in the lowest memory address): "0x78, 0x56, 0x34, 0x12". + + If String has N valid hexadecimal characters for conversion, the caller must make sure Buffer is at least + N/2 (if N is even) or (N+1)/2 (if N if odd) bytes. + + @param Buffer The output buffer allocated by the caller. + @param BufferSizeInBytes On input, the size in bytes of Buffer. On output, it is updated to + contain the size of the Buffer which is actually used for the converstion. + For Unicode string with 2*N hexadecimal characters (not including the + tailing NULL character), N bytes of Buffer will be used for the output. + @param String The input hexadecimal string. + @param ConvertedStrLen The number of hexadecimal characters used to produce content in output + buffer Buffer. + + @retval RETURN_BUFFER_TOO_SMALL The input BufferSizeInBytes is too small to hold the output. BufferSizeInBytes + will be updated to the size required for the converstion. + @retval RETURN_SUCCESS The convertion is successful or the first Unicode character from String + is hexadecimal. If ConvertedStrLen is not NULL, it is updated + to the number of hexadecimal character used for the converstion. +**/ +RETURN_STATUS +EFIAPI +HexStringToBuf ( + OUT UINT8 *Buffer, + IN OUT UINTN *BufferSizeInBytes, + IN CONST CHAR16 *String, + OUT UINTN *ConvertedStrLen OPTIONAL + ) +{ + UINTN HexCnt; + UINTN Idx; + UINTN BufferLength; + UINT8 Digit; + UINT8 Byte; + + // + // Find out how many hex characters the string has. + // + for (Idx = 0, HexCnt = 0; IsHexDigit (&Digit, String[Idx]); Idx++, HexCnt++); + + if (HexCnt == 0) { + *ConvertedStrLen = 0; + return RETURN_SUCCESS; + } + // + // Two Unicode characters make up 1 buffer byte. Round up. + // + BufferLength = (HexCnt + 1) / 2; + + // + // Test if buffer is passed enough. + // + if (BufferLength > (*BufferSizeInBytes)) { + *BufferSizeInBytes = BufferLength; + return RETURN_BUFFER_TOO_SMALL; + } + + *BufferSizeInBytes = BufferLength; + + for (Idx = 0; Idx < HexCnt; Idx++) { + + IsHexDigit (&Digit, String[HexCnt - 1 - Idx]); + + // + // For odd charaters, write the lower nibble for each buffer byte, + // and for even characters, the upper nibble. + // + if ((Idx & 1) == 0) { + Byte = Digit; + } else { + Byte = Buffer[Idx / 2]; + Byte &= 0x0F; + Byte = (UINT8) (Byte | Digit << 4); + } + + Buffer[Idx / 2] = Byte; + } + + if (ConvertedStrLen != NULL) { + *ConvertedStrLen = HexCnt; + } + + return RETURN_SUCCESS; +} + + +/** + Test if a Unicode character is a hexadecimal digit. If true, the input + Unicode character is converted to a byte. + + This function tests if a Unicode character is a hexadecimal digit. If true, the input + Unicode character is converted to a byte. For example, Unicode character + L'A' will be converted to 0x0A. + + If Digit is NULL, then ASSERT. + + @retval TRUE Char is in the range of Hexadecimal number. Digit is updated + to the byte value of the number. + @retval FALSE Char is not in the range of Hexadecimal number. Digit is keep + intact. + +**/ +BOOLEAN +IsHexDigit ( + OUT UINT8 *Digit, + IN CHAR16 Char + ) +{ + ASSERT (Digit != NULL); + + if ((Char >= L'0') && (Char <= L'9')) { + *Digit = (UINT8) (Char - L'0'); + return TRUE; + } + + if ((Char >= L'A') && (Char <= L'F')) { + *Digit = (UINT8) (Char - L'A' + 0x0A); + return TRUE; + } + + if ((Char >= L'a') && (Char <= L'f')) { + *Digit = (UINT8) (Char - L'a' + 0x0A); + return TRUE; + } + + return FALSE; +} + + diff --git a/MdePkg/Library/IfrSupportLib/IfrSupportLib.inf b/MdePkg/Library/IfrSupportLib/IfrSupportLib.inf index a8d5df4c95..98ac18c07c 100644 --- a/MdePkg/Library/IfrSupportLib/IfrSupportLib.inf +++ b/MdePkg/Library/IfrSupportLib/IfrSupportLib.inf @@ -38,8 +38,6 @@ UefiIfrForm.c UefiIfrLibraryInternal.h UefiIfrOpCodeCreation.c - R8Lib.h - R8Lib.c [Packages] @@ -71,4 +69,3 @@ [Pcd] gEfiMdePkgTokenSpaceGuid.PcdUefiVariableDefaultPlatformLang - \ No newline at end of file diff --git a/MdePkg/Library/IfrSupportLib/UefiIfrForm.c b/MdePkg/Library/IfrSupportLib/UefiIfrForm.c index e630e3e39d..8963789423 100644 --- a/MdePkg/Library/IfrSupportLib/UefiIfrForm.c +++ b/MdePkg/Library/IfrSupportLib/UefiIfrForm.c @@ -27,55 +27,6 @@ Abstract: // UINT16 mFakeConfigHdr[] = L"GUID=00000000000000000000000000000000&NAME=0000&PATH=0"; -#if 0 -STATIC -EFI_STATUS -GetPackageDataFromPackageList ( - IN EFI_HII_PACKAGE_LIST_HEADER *HiiPackageList, - IN UINT32 PackageIndex, - OUT UINT32 *BufferLen, - OUT EFI_HII_PACKAGE_HEADER **Buffer - ) -{ - UINT32 Index; - EFI_HII_PACKAGE_HEADER *Package; - UINT32 Offset; - UINT32 PackageListLength; - EFI_HII_PACKAGE_HEADER PackageHeader = {0, 0}; - - ASSERT(HiiPackageList != NULL); - - if ((BufferLen == NULL) || (Buffer == NULL)) { - return EFI_INVALID_PARAMETER; - } - - Package = NULL; - Index = 0; - Offset = sizeof (EFI_HII_PACKAGE_LIST_HEADER); - CopyMem (&PackageListLength, &HiiPackageList->PackageLength, sizeof (UINT32)); - while (Offset < PackageListLength) { - Package = (EFI_HII_PACKAGE_HEADER *) (((UINT8 *) HiiPackageList) + Offset); - CopyMem (&PackageHeader, Package, sizeof (EFI_HII_PACKAGE_HEADER)); - if (Index == PackageIndex) { - break; - } - Offset += PackageHeader.Length; - Index++; - } - if (Offset >= PackageListLength) { - // - // no package found in this Package List - // - return EFI_NOT_FOUND; - } - - *BufferLen = PackageHeader.Length; - *Buffer = Package; - return EFI_SUCCESS; -} -#endif - - /** Draw a dialog and return the selected key. @@ -301,7 +252,7 @@ SwapBuffer ( /** - Converts binary buffer to Unicode string in reversed byte order from R8_BufToHexString(). + Converts binary buffer to Unicode string in reversed byte order from BufToHexString(). @param Str String for output @param Buffer Binary buffer. @@ -326,7 +277,7 @@ BufferToHexString ( SwapBuffer (NewBuffer, BufferSize); StrBufferLen = (BufferSize + 1) * sizeof (CHAR16); - Status = R8_BufToHexString (Str, &StrBufferLen, NewBuffer, BufferSize); + Status = BufToHexString (Str, &StrBufferLen, NewBuffer, BufferSize); gBS->FreePool (NewBuffer); @@ -335,7 +286,7 @@ BufferToHexString ( /** - Converts Hex String to binary buffer in reversed byte order from R8_HexStringToBuf(). + Converts Hex String to binary buffer in reversed byte order from HexStringToBuf(). @param Buffer Pointer to buffer that receives the data. @param BufferSize Length in bytes of the buffer to hold converted @@ -360,7 +311,7 @@ HexStringToBuffer ( UINTN ConvertedStrLen; ConvertedStrLen = 0; - Status = R8_HexStringToBuf (Buffer, BufferSize, Str, &ConvertedStrLen); + Status = HexStringToBuf (Buffer, BufferSize, Str, &ConvertedStrLen); if (!EFI_ERROR (Status)) { SwapBuffer (Buffer, ConvertedStrLen); } @@ -496,7 +447,7 @@ FindBlockName ( Data = 0; BufferSize = sizeof (UINTN); - Status = R8_HexStringToBuf ((UINT8 *) &Data, &BufferSize, String, &ConvertedStrLen); + Status = HexStringToBuf ((UINT8 *) &Data, &BufferSize, String, &ConvertedStrLen); if (EFI_ERROR (Status)) { return FALSE; } @@ -513,7 +464,7 @@ FindBlockName ( Data = 0; BufferSize = sizeof (UINTN); - Status = R8_HexStringToBuf ((UINT8 *) &Data, &BufferSize, String, &ConvertedStrLen); + Status = HexStringToBuf ((UINT8 *) &Data, &BufferSize, String, &ConvertedStrLen); if (EFI_ERROR (Status)) { return FALSE; } @@ -710,7 +661,7 @@ SetBrowserData ( // StringPtr = BlockName + 16; BufferLen = sizeof (BlockName) - (16 * sizeof (CHAR16)); - R8_BufToHexString (StringPtr, &BufferLen, (UINT8 *) &BufferSize, sizeof (UINTN)); + BufToHexString (StringPtr, &BufferLen, (UINT8 *) &BufferSize, sizeof (UINTN)); Request = BlockName; } else { diff --git a/MdePkg/Library/IfrSupportLib/UefiIfrLibraryInternal.h b/MdePkg/Library/IfrSupportLib/UefiIfrLibraryInternal.h index dd41c7aea3..dade8592f5 100644 --- a/MdePkg/Library/IfrSupportLib/UefiIfrLibraryInternal.h +++ b/MdePkg/Library/IfrSupportLib/UefiIfrLibraryInternal.h @@ -40,8 +40,4 @@ Abstract: #include #include -//#include - -#include "R8Lib.h" - #endif -- cgit v1.2.3