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

4 files changed, 246 insertions, 63 deletions

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 <Library/HiiLib.h>
 #include <Library/PcdLib.h>
 
-//#include <MdeModuleHii.h>
-
-#include "R8Lib.h"
-
 #endif