[mirror_edk2.git] / MdePkg / Library / BaseLib / SafeString.c

/** @file\r
  Safe String functions.\r
\r
  Copyright (c) 2014 - 2017, Intel Corporation. All rights reserved.<BR>\r
  This program and the accompanying materials\r
  are licensed and made available under the terms and conditions of the BSD License\r
  which accompanies this distribution.  The full text of the license may be found at\r
  http://opensource.org/licenses/bsd-license.php.\r
\r
  THE PROGRAM IS DISTRIBUTED UNDER THE BSD LICENSE ON AN "AS IS" BASIS,\r
  WITHOUT WARRANTIES OR REPRESENTATIONS OF ANY KIND, EITHER EXPRESS OR IMPLIED.\r
\r
**/\r
\r
#include "BaseLibInternals.h"\r
\r
#define RSIZE_MAX  (PcdGet32 (PcdMaximumUnicodeStringLength))\r
\r
#define ASCII_RSIZE_MAX  (PcdGet32 (PcdMaximumAsciiStringLength))\r
\r
#define SAFE_STRING_CONSTRAINT_CHECK(Expression, Status)  \\r
  do { \\r
    ASSERT (Expression); \\r
    if (!(Expression)) { \\r
      return Status; \\r
    } \\r
  } while (FALSE)\r
\r
/**\r
  Returns if 2 memory blocks are overlapped.\r
\r
  @param  Base1  Base address of 1st memory block.\r
  @param  Size1  Size of 1st memory block.\r
  @param  Base2  Base address of 2nd memory block.\r
  @param  Size2  Size of 2nd memory block.\r
\r
  @retval TRUE  2 memory blocks are overlapped.\r
  @retval FALSE 2 memory blocks are not overlapped.\r
**/\r
BOOLEAN\r
InternalSafeStringIsOverlap (\r
  IN VOID    *Base1,\r
  IN UINTN   Size1,\r
  IN VOID    *Base2,\r
  IN UINTN   Size2\r
  )\r
{\r
  if ((((UINTN)Base1 >= (UINTN)Base2) && ((UINTN)Base1 < (UINTN)Base2 + Size2)) ||\r
      (((UINTN)Base2 >= (UINTN)Base1) && ((UINTN)Base2 < (UINTN)Base1 + Size1))) {\r
    return TRUE;\r
  }\r
  return FALSE;\r
}\r
\r
/**\r
  Returns if 2 Unicode strings are not overlapped.\r
\r
  @param  Str1   Start address of 1st Unicode string.\r
  @param  Size1  The number of char in 1st Unicode string,\r
                 including terminating null char.\r
  @param  Str2   Start address of 2nd Unicode string.\r
  @param  Size2  The number of char in 2nd Unicode string,\r
                 including terminating null char.\r
\r
  @retval TRUE  2 Unicode strings are NOT overlapped.\r
  @retval FALSE 2 Unicode strings are overlapped.\r
**/\r
BOOLEAN\r
InternalSafeStringNoStrOverlap (\r
  IN CHAR16  *Str1,\r
  IN UINTN   Size1,\r
  IN CHAR16  *Str2,\r
  IN UINTN   Size2\r
  )\r
{\r
  return !InternalSafeStringIsOverlap (Str1, Size1 * sizeof(CHAR16), Str2, Size2 * sizeof(CHAR16));\r
}\r
\r
/**\r
  Returns if 2 Ascii strings are not overlapped.\r
\r
  @param  Str1   Start address of 1st Ascii string.\r
  @param  Size1  The number of char in 1st Ascii string,\r
                 including terminating null char.\r
  @param  Str2   Start address of 2nd Ascii string.\r
  @param  Size2  The number of char in 2nd Ascii string,\r
                 including terminating null char.\r
\r
  @retval TRUE  2 Ascii strings are NOT overlapped.\r
  @retval FALSE 2 Ascii strings are overlapped.\r
**/\r
BOOLEAN\r
InternalSafeStringNoAsciiStrOverlap (\r
  IN CHAR8   *Str1,\r
  IN UINTN   Size1,\r
  IN CHAR8   *Str2,\r
  IN UINTN   Size2\r
  )\r
{\r
  return !InternalSafeStringIsOverlap (Str1, Size1, Str2, Size2);\r
}\r
\r
/**\r
  Returns the length of a Null-terminated Unicode string.\r
\r
  This function is similar as strlen_s defined in C11.\r
\r
  If String is not aligned on a 16-bit boundary, then ASSERT().\r
\r
  @param  String   A pointer to a Null-terminated Unicode string.\r
  @param  MaxSize  The maximum number of Destination Unicode\r
                   char, including terminating null char.\r
\r
  @retval 0        If String is NULL.\r
  @retval MaxSize  If there is no null character in the first MaxSize characters of String.\r
  @return The number of characters that percede the terminating null character.\r
\r
**/\r
UINTN\r
EFIAPI\r
StrnLenS (\r
  IN CONST CHAR16              *String,\r
  IN UINTN                     MaxSize\r
  )\r
{\r
  UINTN                             Length;\r
\r
  ASSERT (((UINTN) String & BIT0) == 0);\r
\r
  //\r
  // If String is a null pointer, then the StrnLenS function returns zero.\r
  //\r
  if (String == NULL) {\r
    return 0;\r
  }\r
\r
  //\r
  // Otherwise, the StrnLenS function returns the number of characters that precede the\r
  // terminating null character. If there is no null character in the first MaxSize characters of\r
  // String then StrnLenS returns MaxSize. At most the first MaxSize characters of String shall\r
  // be accessed by StrnLenS.\r
  //\r
  Length = 0;\r
  while (String[Length] != 0) {\r
    if (Length >= MaxSize - 1) {\r
      return MaxSize;\r
    }\r
    Length++;\r
  }\r
  return Length;\r
}\r
\r
/**\r
  Returns the size of a Null-terminated Unicode string in bytes, including the\r
  Null terminator.\r
\r
  This function returns the size of the Null-terminated Unicode string\r
  specified by String in bytes, including the Null terminator.\r
\r
  If String is not aligned on a 16-bit boundary, then ASSERT().\r
\r
  @param  String   A pointer to a Null-terminated Unicode string.\r
  @param  MaxSize  The maximum number of Destination Unicode\r
                   char, including the Null terminator.\r
\r
  @retval 0  If String is NULL.\r
  @retval (sizeof (CHAR16) * (MaxSize + 1))\r
             If there is no Null terminator in the first MaxSize characters of\r
             String.\r
  @return The size of the Null-terminated Unicode string in bytes, including\r
          the Null terminator.\r
\r
**/\r
UINTN\r
EFIAPI\r
StrnSizeS (\r
  IN CONST CHAR16              *String,\r
  IN UINTN                     MaxSize\r
  )\r
{\r
  //\r
  // If String is a null pointer, then the StrnSizeS function returns zero.\r
  //\r
  if (String == NULL) {\r
    return 0;\r
  }\r
\r
  //\r
  // Otherwise, the StrnSizeS function returns the size of the Null-terminated\r
  // Unicode string in bytes, including the Null terminator. If there is no\r
  // Null terminator in the first MaxSize characters of String, then StrnSizeS\r
  // returns (sizeof (CHAR16) * (MaxSize + 1)) to keep a consistent map with\r
  // the StrnLenS function.\r
  //\r
  return (StrnLenS (String, MaxSize) + 1) * sizeof (*String);\r
}\r
\r
/**\r
  Copies the string pointed to by Source (including the terminating null char)\r
  to the array pointed to by Destination.\r
\r
  This function is similar as strcpy_s defined in C11.\r
\r
  If Destination is not aligned on a 16-bit boundary, then ASSERT().\r
  If Source is not aligned on a 16-bit boundary, then ASSERT().\r
  If an error would be returned, then the function will also ASSERT().\r
\r
  If an error is returned, then the Destination is unmodified.\r
\r
  @param  Destination              A pointer to a Null-terminated Unicode string.\r
  @param  DestMax                  The maximum number of Destination Unicode\r
                                   char, including terminating null char.\r
  @param  Source                   A pointer to a Null-terminated Unicode string.\r
\r
  @retval RETURN_SUCCESS           String is copied.\r
  @retval RETURN_BUFFER_TOO_SMALL  If DestMax is NOT greater than StrLen(Source).\r
  @retval RETURN_INVALID_PARAMETER If Destination is NULL.\r
                                   If Source is NULL.\r
                                   If PcdMaximumUnicodeStringLength is not zero,\r
                                    and DestMax is greater than \r
                                    PcdMaximumUnicodeStringLength.\r
                                   If DestMax is 0.\r
  @retval RETURN_ACCESS_DENIED     If Source and Destination overlap.\r
**/\r
RETURN_STATUS\r
EFIAPI\r
StrCpyS (\r
  OUT CHAR16       *Destination,\r
  IN  UINTN        DestMax,\r
  IN  CONST CHAR16 *Source\r
  )\r
{\r
  UINTN            SourceLen;\r
  \r
  ASSERT (((UINTN) Destination & BIT0) == 0);\r
  ASSERT (((UINTN) Source & BIT0) == 0);\r
\r
  //\r
  // 1. Neither Destination nor Source shall be a null pointer.\r
  //\r
  SAFE_STRING_CONSTRAINT_CHECK ((Destination != NULL), RETURN_INVALID_PARAMETER);\r
  SAFE_STRING_CONSTRAINT_CHECK ((Source != NULL), RETURN_INVALID_PARAMETER);\r
\r
  //\r
  // 2. DestMax shall not be greater than RSIZE_MAX.\r
  //\r
  if (RSIZE_MAX != 0) {\r
    SAFE_STRING_CONSTRAINT_CHECK ((DestMax <= RSIZE_MAX), RETURN_INVALID_PARAMETER);\r
  }\r
\r
  //\r
  // 3. DestMax shall not equal zero.\r
  //\r
  SAFE_STRING_CONSTRAINT_CHECK ((DestMax != 0), RETURN_INVALID_PARAMETER);\r
\r
  //\r
  // 4. DestMax shall be greater than StrnLenS(Source, DestMax).\r
  //\r
  SourceLen = StrnLenS (Source, DestMax);\r
  SAFE_STRING_CONSTRAINT_CHECK ((DestMax > SourceLen), RETURN_BUFFER_TOO_SMALL);\r
\r
  //\r
  // 5. Copying shall not take place between objects that overlap.\r
  //\r
  SAFE_STRING_CONSTRAINT_CHECK (InternalSafeStringNoStrOverlap (Destination, DestMax, (CHAR16 *)Source, SourceLen + 1), RETURN_ACCESS_DENIED);\r
\r
  //\r
  // The StrCpyS function copies the string pointed to by Source (including the terminating\r
  // null character) into the array pointed to by Destination.\r
  //\r
  while (*Source != 0) {\r
    *(Destination++) = *(Source++);\r
  }\r
  *Destination = 0;\r
\r
  return RETURN_SUCCESS;\r
}\r
\r
/**\r
  Copies not more than Length successive char from the string pointed to by\r
  Source to the array pointed to by Destination. If no null char is copied from\r
  Source, then Destination[Length] is always set to null.\r
\r
  This function is similar as strncpy_s defined in C11.\r
\r
  If Length > 0 and Destination is not aligned on a 16-bit boundary, then ASSERT().\r
  If Length > 0 and Source is not aligned on a 16-bit boundary, then ASSERT().\r
  If an error would be returned, then the function will also ASSERT().\r
\r
  If an error is returned, then the Destination is unmodified.\r
\r
  @param  Destination              A pointer to a Null-terminated Unicode string.\r
  @param  DestMax                  The maximum number of Destination Unicode\r
                                   char, including terminating null char.\r
  @param  Source                   A pointer to a Null-terminated Unicode string.\r
  @param  Length                   The maximum number of Unicode characters to copy.\r
\r
  @retval RETURN_SUCCESS           String is copied.\r
  @retval RETURN_BUFFER_TOO_SMALL  If DestMax is NOT greater than \r
                                   MIN(StrLen(Source), Length).\r
  @retval RETURN_INVALID_PARAMETER If Destination is NULL.\r
                                   If Source is NULL.\r
                                   If PcdMaximumUnicodeStringLength is not zero,\r
                                    and DestMax is greater than \r
                                    PcdMaximumUnicodeStringLength.\r
                                   If DestMax is 0.\r
  @retval RETURN_ACCESS_DENIED     If Source and Destination overlap.\r
**/\r
RETURN_STATUS\r
EFIAPI\r
StrnCpyS (\r
  OUT CHAR16       *Destination,\r
  IN  UINTN        DestMax,\r
  IN  CONST CHAR16 *Source,\r
  IN  UINTN        Length\r
  )\r
{\r
  UINTN            SourceLen;\r
\r
  ASSERT (((UINTN) Destination & BIT0) == 0);\r
  ASSERT (((UINTN) Source & BIT0) == 0);\r
\r
  //\r
  // 1. Neither Destination nor Source shall be a null pointer.\r
  //\r
  SAFE_STRING_CONSTRAINT_CHECK ((Destination != NULL), RETURN_INVALID_PARAMETER);\r
  SAFE_STRING_CONSTRAINT_CHECK ((Source != NULL), RETURN_INVALID_PARAMETER);\r
\r
  //\r
  // 2. Neither DestMax nor Length shall be greater than RSIZE_MAX\r
  //\r
  if (RSIZE_MAX != 0) {\r
    SAFE_STRING_CONSTRAINT_CHECK ((DestMax <= RSIZE_MAX), RETURN_INVALID_PARAMETER);\r
    SAFE_STRING_CONSTRAINT_CHECK ((Length <= RSIZE_MAX), RETURN_INVALID_PARAMETER);\r
  }\r
\r
  //\r
  // 3. DestMax shall not equal zero.\r
  //\r
  SAFE_STRING_CONSTRAINT_CHECK ((DestMax != 0), RETURN_INVALID_PARAMETER);\r
\r
  //\r
  // 4. If Length is not less than DestMax, then DestMax shall be greater than StrnLenS(Source, DestMax).\r
  //\r
  SourceLen = StrnLenS (Source, DestMax);\r
  if (Length >= DestMax) {\r
    SAFE_STRING_CONSTRAINT_CHECK ((DestMax > SourceLen), RETURN_BUFFER_TOO_SMALL);\r
  }\r
\r
  //\r
  // 5. Copying shall not take place between objects that overlap.\r
  //\r
  if (SourceLen > Length) {\r
    SourceLen = Length;\r
  }\r
  SAFE_STRING_CONSTRAINT_CHECK (InternalSafeStringNoStrOverlap (Destination, DestMax, (CHAR16 *)Source, SourceLen + 1), RETURN_ACCESS_DENIED);\r
\r
  //\r
  // The StrnCpyS function copies not more than Length successive characters (characters that\r
  // follow a null character are not copied) from the array pointed to by Source to the array\r
  // pointed to by Destination. If no null character was copied from Source, then Destination[Length] is set to a null\r
  // character.\r
  //\r
  while ((*Source != 0) && (SourceLen > 0)) {\r
    *(Destination++) = *(Source++);\r
    SourceLen--;\r
  }\r
  *Destination = 0;\r
\r
  return RETURN_SUCCESS;\r
}\r
\r
/**\r
  Appends a copy of the string pointed to by Source (including the terminating\r
  null char) to the end of the string pointed to by Destination.\r
\r
  This function is similar as strcat_s defined in C11.\r
\r
  If Destination is not aligned on a 16-bit boundary, then ASSERT().\r
  If Source is not aligned on a 16-bit boundary, then ASSERT().\r
  If an error would be returned, then the function will also ASSERT().\r
\r
  If an error is returned, then the Destination is unmodified.\r
\r
  @param  Destination              A pointer to a Null-terminated Unicode string.\r
  @param  DestMax                  The maximum number of Destination Unicode\r
                                   char, including terminating null char.\r
  @param  Source                   A pointer to a Null-terminated Unicode string.\r
\r
  @retval RETURN_SUCCESS           String is appended.\r
  @retval RETURN_BAD_BUFFER_SIZE   If DestMax is NOT greater than \r
                                   StrLen(Destination).\r
  @retval RETURN_BUFFER_TOO_SMALL  If (DestMax - StrLen(Destination)) is NOT\r
                                   greater than StrLen(Source).\r
  @retval RETURN_INVALID_PARAMETER If Destination is NULL.\r
                                   If Source is NULL.\r
                                   If PcdMaximumUnicodeStringLength is not zero,\r
                                    and DestMax is greater than \r
                                    PcdMaximumUnicodeStringLength.\r
                                   If DestMax is 0.\r
  @retval RETURN_ACCESS_DENIED     If Source and Destination overlap.\r
**/\r
RETURN_STATUS\r
EFIAPI\r
StrCatS (\r
  IN OUT CHAR16       *Destination,\r
  IN     UINTN        DestMax,\r
  IN     CONST CHAR16 *Source\r
  )\r
{\r
  UINTN               DestLen;\r
  UINTN               CopyLen;\r
  UINTN               SourceLen;\r
  \r
  ASSERT (((UINTN) Destination & BIT0) == 0);\r
  ASSERT (((UINTN) Source & BIT0) == 0);\r
\r
  //\r
  // Let CopyLen denote the value DestMax - StrnLenS(Destination, DestMax) upon entry to StrCatS.\r
  //\r
  DestLen = StrnLenS (Destination, DestMax);\r
  CopyLen = DestMax - DestLen;\r
\r
  //\r
  // 1. Neither Destination nor Source shall be a null pointer.\r
  //\r
  SAFE_STRING_CONSTRAINT_CHECK ((Destination != NULL), RETURN_INVALID_PARAMETER);\r
  SAFE_STRING_CONSTRAINT_CHECK ((Source != NULL), RETURN_INVALID_PARAMETER);\r
\r
  //\r
  // 2. DestMax shall not be greater than RSIZE_MAX.\r
  //\r
  if (RSIZE_MAX != 0) {\r
    SAFE_STRING_CONSTRAINT_CHECK ((DestMax <= RSIZE_MAX), RETURN_INVALID_PARAMETER);\r
  }\r
\r
  //\r
  // 3. DestMax shall not equal zero.\r
  //\r
  SAFE_STRING_CONSTRAINT_CHECK ((DestMax != 0), RETURN_INVALID_PARAMETER);\r
\r
  //\r
  // 4. CopyLen shall not equal zero.\r
  //\r
  SAFE_STRING_CONSTRAINT_CHECK ((CopyLen != 0), RETURN_BAD_BUFFER_SIZE);\r
\r
  //\r
  // 5. CopyLen shall be greater than StrnLenS(Source, CopyLen).\r
  //\r
  SourceLen = StrnLenS (Source, CopyLen);\r
  SAFE_STRING_CONSTRAINT_CHECK ((CopyLen > SourceLen), RETURN_BUFFER_TOO_SMALL);\r
\r
  //\r
  // 6. Copying shall not take place between objects that overlap.\r
  //\r
  SAFE_STRING_CONSTRAINT_CHECK (InternalSafeStringNoStrOverlap (Destination, DestMax, (CHAR16 *)Source, SourceLen + 1), RETURN_ACCESS_DENIED);\r
\r
  //\r
  // The StrCatS function appends a copy of the string pointed to by Source (including the\r
  // terminating null character) to the end of the string pointed to by Destination. The initial character\r
  // from Source overwrites the null character at the end of Destination.\r
  //\r
  Destination = Destination + DestLen;\r
  while (*Source != 0) {\r
    *(Destination++) = *(Source++);\r
  }\r
  *Destination = 0;\r
\r
  return RETURN_SUCCESS;\r
}\r
\r
/**\r
  Appends not more than Length successive char from the string pointed to by\r
  Source to the end of the string pointed to by Destination. If no null char is\r
  copied from Source, then Destination[StrLen(Destination) + Length] is always\r
  set to null.\r
\r
  This function is similar as strncat_s defined in C11.\r
\r
  If Destination is not aligned on a 16-bit boundary, then ASSERT().\r
  If Source is not aligned on a 16-bit boundary, then ASSERT().\r
  If an error would be returned, then the function will also ASSERT().\r
\r
  If an error is returned, then the Destination is unmodified.\r
\r
  @param  Destination              A pointer to a Null-terminated Unicode string.\r
  @param  DestMax                  The maximum number of Destination Unicode\r
                                   char, including terminating null char.\r
  @param  Source                   A pointer to a Null-terminated Unicode string.\r
  @param  Length                   The maximum number of Unicode characters to copy.\r
\r
  @retval RETURN_SUCCESS           String is appended.\r
  @retval RETURN_BAD_BUFFER_SIZE   If DestMax is NOT greater than\r
                                   StrLen(Destination).\r
  @retval RETURN_BUFFER_TOO_SMALL  If (DestMax - StrLen(Destination)) is NOT\r
                                   greater than MIN(StrLen(Source), Length).\r
  @retval RETURN_INVALID_PARAMETER If Destination is NULL.\r
                                   If Source is NULL.\r
                                   If PcdMaximumUnicodeStringLength is not zero,\r
                                    and DestMax is greater than \r
                                    PcdMaximumUnicodeStringLength.\r
                                   If DestMax is 0.\r
  @retval RETURN_ACCESS_DENIED     If Source and Destination overlap.\r
**/\r
RETURN_STATUS\r
EFIAPI\r
StrnCatS (\r
  IN OUT CHAR16       *Destination,\r
  IN     UINTN        DestMax,\r
  IN     CONST CHAR16 *Source,\r
  IN     UINTN        Length\r
  )\r
{\r
  UINTN               DestLen;\r
  UINTN               CopyLen;\r
  UINTN               SourceLen;\r
  \r
  ASSERT (((UINTN) Destination & BIT0) == 0);\r
  ASSERT (((UINTN) Source & BIT0) == 0);\r
\r
  //\r
  // Let CopyLen denote the value DestMax - StrnLenS(Destination, DestMax) upon entry to StrnCatS.\r
  //\r
  DestLen = StrnLenS (Destination, DestMax);\r
  CopyLen = DestMax - DestLen;\r
\r
  //\r
  // 1. Neither Destination nor Source shall be a null pointer.\r
  //\r
  SAFE_STRING_CONSTRAINT_CHECK ((Destination != NULL), RETURN_INVALID_PARAMETER);\r
  SAFE_STRING_CONSTRAINT_CHECK ((Source != NULL), RETURN_INVALID_PARAMETER);\r
\r
  //\r
  // 2. Neither DestMax nor Length shall be greater than RSIZE_MAX.\r
  //\r
  if (RSIZE_MAX != 0) {\r
    SAFE_STRING_CONSTRAINT_CHECK ((DestMax <= RSIZE_MAX), RETURN_INVALID_PARAMETER);\r
    SAFE_STRING_CONSTRAINT_CHECK ((Length <= RSIZE_MAX), RETURN_INVALID_PARAMETER);\r
  }\r
\r
  //\r
  // 3. DestMax shall not equal zero.\r
  //\r
  SAFE_STRING_CONSTRAINT_CHECK ((DestMax != 0), RETURN_INVALID_PARAMETER);\r
\r
  //\r
  // 4. CopyLen shall not equal zero.\r
  //\r
  SAFE_STRING_CONSTRAINT_CHECK ((CopyLen != 0), RETURN_BAD_BUFFER_SIZE);\r
\r
  //\r
  // 5. If Length is not less than CopyLen, then CopyLen shall be greater than StrnLenS(Source, CopyLen).\r
  //\r
  SourceLen = StrnLenS (Source, CopyLen);\r
  if (Length >= CopyLen) {\r
    SAFE_STRING_CONSTRAINT_CHECK ((CopyLen > SourceLen), RETURN_BUFFER_TOO_SMALL);\r
  }\r
\r
  //\r
  // 6. Copying shall not take place between objects that overlap.\r
  //\r
  if (SourceLen > Length) {\r
    SourceLen = Length;\r
  }\r
  SAFE_STRING_CONSTRAINT_CHECK (InternalSafeStringNoStrOverlap (Destination, DestMax, (CHAR16 *)Source, SourceLen + 1), RETURN_ACCESS_DENIED);\r
\r
  //\r
  // The StrnCatS function appends not more than Length successive characters (characters\r
  // that follow a null character are not copied) from the array pointed to by Source to the end of\r
  // the string pointed to by Destination. The initial character from Source overwrites the null character at\r
  // the end of Destination. If no null character was copied from Source, then Destination[DestMax-CopyLen+Length] is set to\r
  // a null character.\r
  //\r
  Destination = Destination + DestLen;\r
  while ((*Source != 0) && (SourceLen > 0)) {\r
    *(Destination++) = *(Source++);\r
    SourceLen--;\r
  }\r
  *Destination = 0;\r
\r
  return RETURN_SUCCESS;\r
}\r
\r
/**\r
  Convert a Null-terminated Unicode decimal string to a value of type UINTN.\r
\r
  This function outputs a value of type UINTN by interpreting the contents of\r
  the Unicode string specified by String as a decimal number. The format of the\r
  input Unicode string String is:\r
\r
                  [spaces] [decimal digits].\r
\r
  The valid decimal digit character is in the range [0-9]. The function will\r
  ignore the pad space, which includes spaces or tab characters, before\r
  [decimal digits]. The running zero in the beginning of [decimal digits] will\r
  be ignored. Then, the function stops at the first character that is a not a\r
  valid decimal character or a Null-terminator, whichever one comes first.\r
\r
  If String is NULL, then ASSERT().\r
  If Data is NULL, then ASSERT().\r
  If String is not aligned in a 16-bit boundary, then ASSERT().\r
  If PcdMaximumUnicodeStringLength is not zero, and String contains more than\r
  PcdMaximumUnicodeStringLength Unicode characters, not including the\r
  Null-terminator, then ASSERT().\r
\r
  If String has no valid decimal digits in the above format, then 0 is stored\r
  at the location pointed to by Data.\r
  If the number represented by String exceeds the range defined by UINTN, then\r
  MAX_UINTN is stored at the location pointed to by Data.\r
\r
  If EndPointer is not NULL, a pointer to the character that stopped the scan\r
  is stored at the location pointed to by EndPointer. If String has no valid\r
  decimal digits right after the optional pad spaces, the value of String is\r
  stored at the location pointed to by EndPointer.\r
\r
  @param  String                   Pointer to a Null-terminated Unicode string.\r
  @param  EndPointer               Pointer to character that stops scan.\r
  @param  Data                     Pointer to the converted value.\r
\r
  @retval RETURN_SUCCESS           Value is translated from String.\r
  @retval RETURN_INVALID_PARAMETER If String is NULL.\r
                                   If Data is NULL.\r
                                   If PcdMaximumUnicodeStringLength is not\r
                                   zero, and String contains more than\r
                                   PcdMaximumUnicodeStringLength Unicode\r
                                   characters, not including the\r
                                   Null-terminator.\r
  @retval RETURN_UNSUPPORTED       If the number represented by String exceeds\r
                                   the range defined by UINTN.\r
\r
**/\r
RETURN_STATUS\r
EFIAPI\r
StrDecimalToUintnS (\r
  IN  CONST CHAR16             *String,\r
  OUT       CHAR16             **EndPointer,  OPTIONAL\r
  OUT       UINTN              *Data\r
  )\r
{\r
  ASSERT (((UINTN) String & BIT0) == 0);\r
\r
  //\r
  // 1. Neither String nor Data shall be a null pointer.\r
  //\r
  SAFE_STRING_CONSTRAINT_CHECK ((String != NULL), RETURN_INVALID_PARAMETER);\r
  SAFE_STRING_CONSTRAINT_CHECK ((Data != NULL), RETURN_INVALID_PARAMETER);\r
\r
  //\r
  // 2. The length of String shall not be greater than RSIZE_MAX.\r
  //\r
  if (RSIZE_MAX != 0) {\r
    SAFE_STRING_CONSTRAINT_CHECK ((StrnLenS (String, RSIZE_MAX + 1) <= RSIZE_MAX), RETURN_INVALID_PARAMETER);\r
  }\r
\r
  if (EndPointer != NULL) {\r
    *EndPointer = (CHAR16 *) String;\r
  }\r
\r
  //\r
  // Ignore the pad spaces (space or tab)\r
  //\r
  while ((*String == L' ') || (*String == L'\t')) {\r
    String++;\r
  }\r
\r
  //\r
  // Ignore leading Zeros after the spaces\r
  //\r
  while (*String == L'0') {\r
    String++;\r
  }\r
\r
  *Data = 0;\r
\r
  while (InternalIsDecimalDigitCharacter (*String)) {\r
    //\r
    // If the number represented by String overflows according to the range\r
    // defined by UINTN, then MAX_UINTN is stored in *Data and\r
    // RETURN_UNSUPPORTED is returned.\r
    //\r
    if (*Data > ((MAX_UINTN - (*String - L'0')) / 10)) {\r
      *Data = MAX_UINTN;\r
      if (EndPointer != NULL) {\r
        *EndPointer = (CHAR16 *) String;\r
      }\r
      return RETURN_UNSUPPORTED;\r
    }\r
\r
    *Data = *Data * 10 + (*String - L'0');\r
    String++;\r
  }\r
\r
  if (EndPointer != NULL) {\r
    *EndPointer = (CHAR16 *) String;\r
  }\r
  return RETURN_SUCCESS;\r
}\r
\r
/**\r
  Convert a Null-terminated Unicode decimal string to a value of type UINT64.\r
\r
  This function outputs a value of type UINT64 by interpreting the contents of\r
  the Unicode string specified by String as a decimal number. The format of the\r
  input Unicode string String is:\r
\r
                  [spaces] [decimal digits].\r
\r
  The valid decimal digit character is in the range [0-9]. The function will\r
  ignore the pad space, which includes spaces or tab characters, before\r
  [decimal digits]. The running zero in the beginning of [decimal digits] will\r
  be ignored. Then, the function stops at the first character that is a not a\r
  valid decimal character or a Null-terminator, whichever one comes first.\r
\r
  If String is NULL, then ASSERT().\r
  If Data is NULL, then ASSERT().\r
  If String is not aligned in a 16-bit boundary, then ASSERT().\r
  If PcdMaximumUnicodeStringLength is not zero, and String contains more than\r
  PcdMaximumUnicodeStringLength Unicode characters, not including the\r
  Null-terminator, then ASSERT().\r
\r
  If String has no valid decimal digits in the above format, then 0 is stored\r
  at the location pointed to by Data.\r
  If the number represented by String exceeds the range defined by UINT64, then\r
  MAX_UINT64 is stored at the location pointed to by Data.\r
\r
  If EndPointer is not NULL, a pointer to the character that stopped the scan\r
  is stored at the location pointed to by EndPointer. If String has no valid\r
  decimal digits right after the optional pad spaces, the value of String is\r
  stored at the location pointed to by EndPointer.\r
\r
  @param  String                   Pointer to a Null-terminated Unicode string.\r
  @param  EndPointer               Pointer to character that stops scan.\r
  @param  Data                     Pointer to the converted value.\r
\r
  @retval RETURN_SUCCESS           Value is translated from String.\r
  @retval RETURN_INVALID_PARAMETER If String is NULL.\r
                                   If Data is NULL.\r
                                   If PcdMaximumUnicodeStringLength is not\r
                                   zero, and String contains more than\r
                                   PcdMaximumUnicodeStringLength Unicode\r
                                   characters, not including the\r
                                   Null-terminator.\r
  @retval RETURN_UNSUPPORTED       If the number represented by String exceeds\r
                                   the range defined by UINT64.\r
\r
**/\r
RETURN_STATUS\r
EFIAPI\r
StrDecimalToUint64S (\r
  IN  CONST CHAR16             *String,\r
  OUT       CHAR16             **EndPointer,  OPTIONAL\r
  OUT       UINT64             *Data\r
  )\r
{\r
  ASSERT (((UINTN) String & BIT0) == 0);\r
\r
  //\r
  // 1. Neither String nor Data shall be a null pointer.\r
  //\r
  SAFE_STRING_CONSTRAINT_CHECK ((String != NULL), RETURN_INVALID_PARAMETER);\r
  SAFE_STRING_CONSTRAINT_CHECK ((Data != NULL), RETURN_INVALID_PARAMETER);\r
\r
  //\r
  // 2. The length of String shall not be greater than RSIZE_MAX.\r
  //\r
  if (RSIZE_MAX != 0) {\r
    SAFE_STRING_CONSTRAINT_CHECK ((StrnLenS (String, RSIZE_MAX + 1) <= RSIZE_MAX), RETURN_INVALID_PARAMETER);\r
  }\r
\r
  if (EndPointer != NULL) {\r
    *EndPointer = (CHAR16 *) String;\r
  }\r
\r
  //\r
  // Ignore the pad spaces (space or tab)\r
  //\r
  while ((*String == L' ') || (*String == L'\t')) {\r
    String++;\r
  }\r
\r
  //\r
  // Ignore leading Zeros after the spaces\r
  //\r
  while (*String == L'0') {\r
    String++;\r
  }\r
\r
  *Data = 0;\r
\r
  while (InternalIsDecimalDigitCharacter (*String)) {\r
    //\r
    // If the number represented by String overflows according to the range\r
    // defined by UINT64, then MAX_UINT64 is stored in *Data and\r
    // RETURN_UNSUPPORTED is returned.\r
    //\r
    if (*Data > DivU64x32 (MAX_UINT64 - (*String - L'0'), 10)) {\r
      *Data = MAX_UINT64;\r
      if (EndPointer != NULL) {\r
        *EndPointer = (CHAR16 *) String;\r
      }\r
      return RETURN_UNSUPPORTED;\r
    }\r
\r
    *Data = MultU64x32 (*Data, 10) + (*String - L'0');\r
    String++;\r
  }\r
\r
  if (EndPointer != NULL) {\r
    *EndPointer = (CHAR16 *) String;\r
  }\r
  return RETURN_SUCCESS;\r
}\r
\r
/**\r
  Convert a Null-terminated Unicode hexadecimal string to a value of type\r
  UINTN.\r
\r
  This function outputs a value of type UINTN by interpreting the contents of\r
  the Unicode string specified by String as a hexadecimal number. The format of\r
  the input Unicode string String is:\r
\r
                  [spaces][zeros][x][hexadecimal digits].\r
\r
  The valid hexadecimal digit character is in the range [0-9], [a-f] and [A-F].\r
  The prefix "0x" is optional. Both "x" and "X" is allowed in "0x" prefix.\r
  If "x" appears in the input string, it must be prefixed with at least one 0.\r
  The function will ignore the pad space, which includes spaces or tab\r
  characters, before [zeros], [x] or [hexadecimal digit]. The running zero\r
  before [x] or [hexadecimal digit] will be ignored. Then, the decoding starts\r
  after [x] or the first valid hexadecimal digit. Then, the function stops at\r
  the first character that is a not a valid hexadecimal character or NULL,\r
  whichever one comes first.\r
\r
  If String is NULL, then ASSERT().\r
  If Data is NULL, then ASSERT().\r
  If String is not aligned in a 16-bit boundary, then ASSERT().\r
  If PcdMaximumUnicodeStringLength is not zero, and String contains more than\r
  PcdMaximumUnicodeStringLength Unicode characters, not including the\r
  Null-terminator, then ASSERT().\r
\r
  If String has no valid hexadecimal digits in the above format, then 0 is\r
  stored at the location pointed to by Data.\r
  If the number represented by String exceeds the range defined by UINTN, then\r
  MAX_UINTN is stored at the location pointed to by Data.\r
\r
  If EndPointer is not NULL, a pointer to the character that stopped the scan\r
  is stored at the location pointed to by EndPointer. If String has no valid\r
  hexadecimal digits right after the optional pad spaces, the value of String\r
  is stored at the location pointed to by EndPointer.\r
\r
  @param  String                   Pointer to a Null-terminated Unicode string.\r
  @param  EndPointer               Pointer to character that stops scan.\r
  @param  Data                     Pointer to the converted value.\r
\r
  @retval RETURN_SUCCESS           Value is translated from String.\r
  @retval RETURN_INVALID_PARAMETER If String is NULL.\r
                                   If Data is NULL.\r
                                   If PcdMaximumUnicodeStringLength is not\r
                                   zero, and String contains more than\r
                                   PcdMaximumUnicodeStringLength Unicode\r
                                   characters, not including the\r
                                   Null-terminator.\r
  @retval RETURN_UNSUPPORTED       If the number represented by String exceeds\r
                                   the range defined by UINTN.\r
\r
**/\r
RETURN_STATUS\r
EFIAPI\r
StrHexToUintnS (\r
  IN  CONST CHAR16             *String,\r
  OUT       CHAR16             **EndPointer,  OPTIONAL\r
  OUT       UINTN              *Data\r
  )\r
{\r
  ASSERT (((UINTN) String & BIT0) == 0);\r
\r
  //\r
  // 1. Neither String nor Data shall be a null pointer.\r
  //\r
  SAFE_STRING_CONSTRAINT_CHECK ((String != NULL), RETURN_INVALID_PARAMETER);\r
  SAFE_STRING_CONSTRAINT_CHECK ((Data != NULL), RETURN_INVALID_PARAMETER);\r
\r
  //\r
  // 2. The length of String shall not be greater than RSIZE_MAX.\r
  //\r
  if (RSIZE_MAX != 0) {\r
    SAFE_STRING_CONSTRAINT_CHECK ((StrnLenS (String, RSIZE_MAX + 1) <= RSIZE_MAX), RETURN_INVALID_PARAMETER);\r
  }\r
\r
  if (EndPointer != NULL) {\r
    *EndPointer = (CHAR16 *) String;\r
  }\r
\r
  //\r
  // Ignore the pad spaces (space or tab)\r
  //\r
  while ((*String == L' ') || (*String == L'\t')) {\r
    String++;\r
  }\r
\r
  //\r
  // Ignore leading Zeros after the spaces\r
  //\r
  while (*String == L'0') {\r
    String++;\r
  }\r
\r
  if (InternalCharToUpper (*String) == L'X') {\r
    if (*(String - 1) != L'0') {\r
      *Data = 0;\r
      return RETURN_SUCCESS;\r
    }\r
    //\r
    // Skip the 'X'\r
    //\r
    String++;\r
  }\r
\r
  *Data = 0;\r
\r
  while (InternalIsHexaDecimalDigitCharacter (*String)) {\r
    //\r
    // If the number represented by String overflows according to the range\r
    // defined by UINTN, then MAX_UINTN is stored in *Data and\r
    // RETURN_UNSUPPORTED is returned.\r
    //\r
    if (*Data > ((MAX_UINTN - InternalHexCharToUintn (*String)) >> 4)) {\r
      *Data = MAX_UINTN;\r
      if (EndPointer != NULL) {\r
        *EndPointer = (CHAR16 *) String;\r
      }\r
      return RETURN_UNSUPPORTED;\r
    }\r
\r
    *Data = (*Data << 4) + InternalHexCharToUintn (*String);\r
    String++;\r
  }\r
\r
  if (EndPointer != NULL) {\r
    *EndPointer = (CHAR16 *) String;\r
  }\r
  return RETURN_SUCCESS;\r
}\r
\r
/**\r
  Convert a Null-terminated Unicode hexadecimal string to a value of type\r
  UINT64.\r
\r
  This function outputs a value of type UINT64 by interpreting the contents of\r
  the Unicode string specified by String as a hexadecimal number. The format of\r
  the input Unicode string String is:\r
\r
                  [spaces][zeros][x][hexadecimal digits].\r
\r
  The valid hexadecimal digit character is in the range [0-9], [a-f] and [A-F].\r
  The prefix "0x" is optional. Both "x" and "X" is allowed in "0x" prefix.\r
  If "x" appears in the input string, it must be prefixed with at least one 0.\r
  The function will ignore the pad space, which includes spaces or tab\r
  characters, before [zeros], [x] or [hexadecimal digit]. The running zero\r
  before [x] or [hexadecimal digit] will be ignored. Then, the decoding starts\r
  after [x] or the first valid hexadecimal digit. Then, the function stops at\r
  the first character that is a not a valid hexadecimal character or NULL,\r
  whichever one comes first.\r
\r
  If String is NULL, then ASSERT().\r
  If Data is NULL, then ASSERT().\r
  If String is not aligned in a 16-bit boundary, then ASSERT().\r
  If PcdMaximumUnicodeStringLength is not zero, and String contains more than\r
  PcdMaximumUnicodeStringLength Unicode characters, not including the\r
  Null-terminator, then ASSERT().\r
\r
  If String has no valid hexadecimal digits in the above format, then 0 is\r
  stored at the location pointed to by Data.\r
  If the number represented by String exceeds the range defined by UINT64, then\r
  MAX_UINT64 is stored at the location pointed to by Data.\r
\r
  If EndPointer is not NULL, a pointer to the character that stopped the scan\r
  is stored at the location pointed to by EndPointer. If String has no valid\r
  hexadecimal digits right after the optional pad spaces, the value of String\r
  is stored at the location pointed to by EndPointer.\r
\r
  @param  String                   Pointer to a Null-terminated Unicode string.\r
  @param  EndPointer               Pointer to character that stops scan.\r
  @param  Data                     Pointer to the converted value.\r
\r
  @retval RETURN_SUCCESS           Value is translated from String.\r
  @retval RETURN_INVALID_PARAMETER If String is NULL.\r
                                   If Data is NULL.\r
                                   If PcdMaximumUnicodeStringLength is not\r
                                   zero, and String contains more than\r
                                   PcdMaximumUnicodeStringLength Unicode\r
                                   characters, not including the\r
                                   Null-terminator.\r
  @retval RETURN_UNSUPPORTED       If the number represented by String exceeds\r
                                   the range defined by UINT64.\r
\r
**/\r
RETURN_STATUS\r
EFIAPI\r
StrHexToUint64S (\r
  IN  CONST CHAR16             *String,\r
  OUT       CHAR16             **EndPointer,  OPTIONAL\r
  OUT       UINT64             *Data\r
  )\r
{\r
  ASSERT (((UINTN) String & BIT0) == 0);\r
\r
  //\r
  // 1. Neither String nor Data shall be a null pointer.\r
  //\r
  SAFE_STRING_CONSTRAINT_CHECK ((String != NULL), RETURN_INVALID_PARAMETER);\r
  SAFE_STRING_CONSTRAINT_CHECK ((Data != NULL), RETURN_INVALID_PARAMETER);\r
\r
  //\r
  // 2. The length of String shall not be greater than RSIZE_MAX.\r
  //\r
  if (RSIZE_MAX != 0) {\r
    SAFE_STRING_CONSTRAINT_CHECK ((StrnLenS (String, RSIZE_MAX + 1) <= RSIZE_MAX), RETURN_INVALID_PARAMETER);\r
  }\r
\r
  if (EndPointer != NULL) {\r
    *EndPointer = (CHAR16 *) String;\r
  }\r
\r
  //\r
  // Ignore the pad spaces (space or tab)\r
  //\r
  while ((*String == L' ') || (*String == L'\t')) {\r
    String++;\r
  }\r
\r
  //\r
  // Ignore leading Zeros after the spaces\r
  //\r
  while (*String == L'0') {\r
    String++;\r
  }\r
\r
  if (InternalCharToUpper (*String) == L'X') {\r
    if (*(String - 1) != L'0') {\r
      *Data = 0;\r
      return RETURN_SUCCESS;\r
    }\r
    //\r
    // Skip the 'X'\r
    //\r
    String++;\r
  }\r
\r
  *Data = 0;\r
\r
  while (InternalIsHexaDecimalDigitCharacter (*String)) {\r
    //\r
    // If the number represented by String overflows according to the range\r
    // defined by UINT64, then MAX_UINT64 is stored in *Data and\r
    // RETURN_UNSUPPORTED is returned.\r
    //\r
    if (*Data > RShiftU64 (MAX_UINT64 - InternalHexCharToUintn (*String), 4)) {\r
      *Data = MAX_UINT64;\r
      if (EndPointer != NULL) {\r
        *EndPointer = (CHAR16 *) String;\r
      }\r
      return RETURN_UNSUPPORTED;\r
    }\r
\r
    *Data = LShiftU64 (*Data, 4) + InternalHexCharToUintn (*String);\r
    String++;\r
  }\r
\r
  if (EndPointer != NULL) {\r
    *EndPointer = (CHAR16 *) String;\r
  }\r
  return RETURN_SUCCESS;\r
}\r
\r
/**\r
  Returns the length of a Null-terminated Ascii string.\r
\r
  This function is similar as strlen_s defined in C11.\r
\r
  @param  String   A pointer to a Null-terminated Ascii string.\r
  @param  MaxSize  The maximum number of Destination Ascii\r
                   char, including terminating null char.\r
\r
  @retval 0        If String is NULL.\r
  @retval MaxSize  If there is no null character in the first MaxSize characters of String.\r
  @return The number of characters that percede the terminating null character.\r
\r
**/\r
UINTN\r
EFIAPI\r
AsciiStrnLenS (\r
  IN CONST CHAR8               *String,\r
  IN UINTN                     MaxSize\r
  )\r
{\r
  UINTN                             Length;\r
\r
  //\r
  // If String is a null pointer, then the AsciiStrnLenS function returns zero.\r
  //\r
  if (String == NULL) {\r
    return 0;\r
  }\r
\r
  //\r
  // Otherwise, the AsciiStrnLenS function returns the number of characters that precede the\r
  // terminating null character. If there is no null character in the first MaxSize characters of\r
  // String then AsciiStrnLenS returns MaxSize. At most the first MaxSize characters of String shall\r
  // be accessed by AsciiStrnLenS.\r
  //\r
  Length = 0;\r
  while (String[Length] != 0) {\r
    if (Length >= MaxSize - 1) {\r
      return MaxSize;\r
    }\r
    Length++;\r
  }\r
  return Length;\r
}\r
\r
/**\r
  Returns the size of a Null-terminated Ascii string in bytes, including the\r
  Null terminator.\r
\r
  This function returns the size of the Null-terminated Ascii string specified\r
  by String in bytes, including the Null terminator.\r
\r
  @param  String   A pointer to a Null-terminated Ascii string.\r
  @param  MaxSize  The maximum number of Destination Ascii\r
                   char, including the Null terminator.\r
\r
  @retval 0  If String is NULL.\r
  @retval (sizeof (CHAR8) * (MaxSize + 1))\r
             If there is no Null terminator in the first MaxSize characters of\r
             String.\r
  @return The size of the Null-terminated Ascii string in bytes, including the\r
          Null terminator.\r
\r
**/\r
UINTN\r
EFIAPI\r
AsciiStrnSizeS (\r
  IN CONST CHAR8               *String,\r
  IN UINTN                     MaxSize\r
  )\r
{\r
  //\r
  // If String is a null pointer, then the AsciiStrnSizeS function returns\r
  // zero.\r
  //\r
  if (String == NULL) {\r
    return 0;\r
  }\r
\r
  //\r
  // Otherwise, the AsciiStrnSizeS function returns the size of the\r
  // Null-terminated Ascii string in bytes, including the Null terminator. If\r
  // there is no Null terminator in the first MaxSize characters of String,\r
  // then AsciiStrnSizeS returns (sizeof (CHAR8) * (MaxSize + 1)) to keep a\r
  // consistent map with the AsciiStrnLenS function.\r
  //\r
  return (AsciiStrnLenS (String, MaxSize) + 1) * sizeof (*String);\r
}\r
\r
/**\r
  Copies the string pointed to by Source (including the terminating null char)\r
  to the array pointed to by Destination.\r
\r
  This function is similar as strcpy_s defined in C11.\r
\r
  If an error would be returned, then the function will also ASSERT().\r
\r
  If an error is returned, then the Destination is unmodified.\r
\r
  @param  Destination              A pointer to a Null-terminated Ascii string.\r
  @param  DestMax                  The maximum number of Destination Ascii\r
                                   char, including terminating null char.\r
  @param  Source                   A pointer to a Null-terminated Ascii string.\r
\r
  @retval RETURN_SUCCESS           String is copied.\r
  @retval RETURN_BUFFER_TOO_SMALL  If DestMax is NOT greater than StrLen(Source).\r
  @retval RETURN_INVALID_PARAMETER If Destination is NULL.\r
                                   If Source is NULL.\r
                                   If PcdMaximumAsciiStringLength is not zero,\r
                                    and DestMax is greater than \r
                                    PcdMaximumAsciiStringLength.\r
                                   If DestMax is 0.\r
  @retval RETURN_ACCESS_DENIED     If Source and Destination overlap.\r
**/\r
RETURN_STATUS\r
EFIAPI\r
AsciiStrCpyS (\r
  OUT CHAR8        *Destination,\r
  IN  UINTN        DestMax,\r
  IN  CONST CHAR8  *Source\r
  )\r
{\r
  UINTN            SourceLen;\r
  \r
  //\r
  // 1. Neither Destination nor Source shall be a null pointer.\r
  //\r
  SAFE_STRING_CONSTRAINT_CHECK ((Destination != NULL), RETURN_INVALID_PARAMETER);\r
  SAFE_STRING_CONSTRAINT_CHECK ((Source != NULL), RETURN_INVALID_PARAMETER);\r
\r
  //\r
  // 2. DestMax shall not be greater than ASCII_RSIZE_MAX.\r
  //\r
  if (ASCII_RSIZE_MAX != 0) {\r
    SAFE_STRING_CONSTRAINT_CHECK ((DestMax <= ASCII_RSIZE_MAX), RETURN_INVALID_PARAMETER);\r
  }\r
\r
  //\r
  // 3. DestMax shall not equal zero.\r
  //\r
  SAFE_STRING_CONSTRAINT_CHECK ((DestMax != 0), RETURN_INVALID_PARAMETER);\r
\r
  //\r
  // 4. DestMax shall be greater than AsciiStrnLenS(Source, DestMax).\r
  //\r
  SourceLen = AsciiStrnLenS (Source, DestMax);\r
  SAFE_STRING_CONSTRAINT_CHECK ((DestMax > SourceLen), RETURN_BUFFER_TOO_SMALL);\r
\r
  //\r
  // 5. Copying shall not take place between objects that overlap.\r
  //\r
  SAFE_STRING_CONSTRAINT_CHECK (InternalSafeStringNoAsciiStrOverlap (Destination, DestMax, (CHAR8 *)Source, SourceLen + 1), RETURN_ACCESS_DENIED);\r
\r
  //\r
  // The AsciiStrCpyS function copies the string pointed to by Source (including the terminating\r
  // null character) into the array pointed to by Destination.\r
  //\r
  while (*Source != 0) {\r
    *(Destination++) = *(Source++);\r
  }\r
  *Destination = 0;\r
\r
  return RETURN_SUCCESS;\r
}\r
\r
/**\r
  Copies not more than Length successive char from the string pointed to by\r
  Source to the array pointed to by Destination. If no null char is copied from\r
  Source, then Destination[Length] is always set to null.\r
\r
  This function is similar as strncpy_s defined in C11.\r
\r
  If an error would be returned, then the function will also ASSERT().\r
\r
  If an error is returned, then the Destination is unmodified.\r
\r
  @param  Destination              A pointer to a Null-terminated Ascii string.\r
  @param  DestMax                  The maximum number of Destination Ascii\r
                                   char, including terminating null char.\r
  @param  Source                   A pointer to a Null-terminated Ascii string.\r
  @param  Length                   The maximum number of Ascii characters to copy.\r
\r
  @retval RETURN_SUCCESS           String is copied.\r
  @retval RETURN_BUFFER_TOO_SMALL  If DestMax is NOT greater than \r
                                   MIN(StrLen(Source), Length).\r
  @retval RETURN_INVALID_PARAMETER If Destination is NULL.\r
                                   If Source is NULL.\r
                                   If PcdMaximumAsciiStringLength is not zero,\r
                                    and DestMax is greater than \r
                                    PcdMaximumAsciiStringLength.\r
                                   If DestMax is 0.\r
  @retval RETURN_ACCESS_DENIED     If Source and Destination overlap.\r
**/\r
RETURN_STATUS\r
EFIAPI\r
AsciiStrnCpyS (\r
  OUT CHAR8        *Destination,\r
  IN  UINTN        DestMax,\r
  IN  CONST CHAR8  *Source,\r
  IN  UINTN        Length\r
  )\r
{\r
  UINTN            SourceLen;\r
\r
  //\r
  // 1. Neither Destination nor Source shall be a null pointer.\r
  //\r
  SAFE_STRING_CONSTRAINT_CHECK ((Destination != NULL), RETURN_INVALID_PARAMETER);\r
  SAFE_STRING_CONSTRAINT_CHECK ((Source != NULL), RETURN_INVALID_PARAMETER);\r
\r
  //\r
  // 2. Neither DestMax nor Length shall be greater than ASCII_RSIZE_MAX\r
  //\r
  if (ASCII_RSIZE_MAX != 0) {\r
    SAFE_STRING_CONSTRAINT_CHECK ((DestMax <= ASCII_RSIZE_MAX), RETURN_INVALID_PARAMETER);\r
    SAFE_STRING_CONSTRAINT_CHECK ((Length <= ASCII_RSIZE_MAX), RETURN_INVALID_PARAMETER);\r
  }\r
\r
  //\r
  // 3. DestMax shall not equal zero.\r
  //\r
  SAFE_STRING_CONSTRAINT_CHECK ((DestMax != 0), RETURN_INVALID_PARAMETER);\r
\r
  //\r
  // 4. If Length is not less than DestMax, then DestMax shall be greater than AsciiStrnLenS(Source, DestMax).\r
  //\r
  SourceLen = AsciiStrnLenS (Source, DestMax);\r
  if (Length >= DestMax) {\r
    SAFE_STRING_CONSTRAINT_CHECK ((DestMax > SourceLen), RETURN_BUFFER_TOO_SMALL);\r
  }\r
\r
  //\r
  // 5. Copying shall not take place between objects that overlap.\r
  //\r
  if (SourceLen > Length) {\r
    SourceLen = Length;\r
  }\r
  SAFE_STRING_CONSTRAINT_CHECK (InternalSafeStringNoAsciiStrOverlap (Destination, DestMax, (CHAR8 *)Source, SourceLen + 1), RETURN_ACCESS_DENIED);\r
\r
  //\r
  // The AsciiStrnCpyS function copies not more than Length successive characters (characters that\r
  // follow a null character are not copied) from the array pointed to by Source to the array\r
  // pointed to by Destination. If no null character was copied from Source, then Destination[Length] is set to a null\r
  // character.\r
  //\r
  while ((*Source != 0) && (SourceLen > 0)) {\r
    *(Destination++) = *(Source++);\r
    SourceLen--;\r
  }\r
  *Destination = 0;\r
\r
  return RETURN_SUCCESS;\r
}\r
\r
/**\r
  Appends a copy of the string pointed to by Source (including the terminating\r
  null char) to the end of the string pointed to by Destination.\r
\r
  This function is similar as strcat_s defined in C11.\r
\r
  If an error would be returned, then the function will also ASSERT().\r
\r
  If an error is returned, then the Destination is unmodified.\r
\r
  @param  Destination              A pointer to a Null-terminated Ascii string.\r
  @param  DestMax                  The maximum number of Destination Ascii\r
                                   char, including terminating null char.\r
  @param  Source                   A pointer to a Null-terminated Ascii string.\r
\r
  @retval RETURN_SUCCESS           String is appended.\r
  @retval RETURN_BAD_BUFFER_SIZE   If DestMax is NOT greater than \r
                                   StrLen(Destination).\r
  @retval RETURN_BUFFER_TOO_SMALL  If (DestMax - StrLen(Destination)) is NOT\r
                                   greater than StrLen(Source).\r
  @retval RETURN_INVALID_PARAMETER If Destination is NULL.\r
                                   If Source is NULL.\r
                                   If PcdMaximumAsciiStringLength is not zero,\r
                                    and DestMax is greater than \r
                                    PcdMaximumAsciiStringLength.\r
                                   If DestMax is 0.\r
  @retval RETURN_ACCESS_DENIED     If Source and Destination overlap.\r
**/\r
RETURN_STATUS\r
EFIAPI\r
AsciiStrCatS (\r
  IN OUT CHAR8        *Destination,\r
  IN     UINTN        DestMax,\r
  IN     CONST CHAR8  *Source\r
  )\r
{\r
  UINTN               DestLen;\r
  UINTN               CopyLen;\r
  UINTN               SourceLen;\r
  \r
  //\r
  // Let CopyLen denote the value DestMax - AsciiStrnLenS(Destination, DestMax) upon entry to AsciiStrCatS.\r
  //\r
  DestLen = AsciiStrnLenS (Destination, DestMax);\r
  CopyLen = DestMax - DestLen;\r
\r
  //\r
  // 1. Neither Destination nor Source shall be a null pointer.\r
  //\r
  SAFE_STRING_CONSTRAINT_CHECK ((Destination != NULL), RETURN_INVALID_PARAMETER);\r
  SAFE_STRING_CONSTRAINT_CHECK ((Source != NULL), RETURN_INVALID_PARAMETER);\r
\r
  //\r
  // 2. DestMax shall not be greater than ASCII_RSIZE_MAX.\r
  //\r
  if (ASCII_RSIZE_MAX != 0) {\r
    SAFE_STRING_CONSTRAINT_CHECK ((DestMax <= ASCII_RSIZE_MAX), RETURN_INVALID_PARAMETER);\r
  }\r
\r
  //\r
  // 3. DestMax shall not equal zero.\r
  //\r
  SAFE_STRING_CONSTRAINT_CHECK ((DestMax != 0), RETURN_INVALID_PARAMETER);\r
\r
  //\r
  // 4. CopyLen shall not equal zero.\r
  //\r
  SAFE_STRING_CONSTRAINT_CHECK ((CopyLen != 0), RETURN_BAD_BUFFER_SIZE);\r
\r
  //\r
  // 5. CopyLen shall be greater than AsciiStrnLenS(Source, CopyLen).\r
  //\r
  SourceLen = AsciiStrnLenS (Source, CopyLen);\r
  SAFE_STRING_CONSTRAINT_CHECK ((CopyLen > SourceLen), RETURN_BUFFER_TOO_SMALL);\r
\r
  //\r
  // 6. Copying shall not take place between objects that overlap.\r
  //\r
  SAFE_STRING_CONSTRAINT_CHECK (InternalSafeStringNoAsciiStrOverlap (Destination, DestMax, (CHAR8 *)Source, SourceLen + 1), RETURN_ACCESS_DENIED);\r
\r
  //\r
  // The AsciiStrCatS function appends a copy of the string pointed to by Source (including the\r
  // terminating null character) to the end of the string pointed to by Destination. The initial character\r
  // from Source overwrites the null character at the end of Destination.\r
  //\r
  Destination = Destination + DestLen;\r
  while (*Source != 0) {\r
    *(Destination++) = *(Source++);\r
  }\r
  *Destination = 0;\r
\r
  return RETURN_SUCCESS;\r
}\r
\r
/**\r
  Appends not more than Length successive char from the string pointed to by\r
  Source to the end of the string pointed to by Destination. If no null char is\r
  copied from Source, then Destination[StrLen(Destination) + Length] is always\r
  set to null.\r
\r
  This function is similar as strncat_s defined in C11.\r
\r
  If an error would be returned, then the function will also ASSERT().\r
\r
  If an error is returned, then the Destination is unmodified.\r
\r
  @param  Destination              A pointer to a Null-terminated Ascii string.\r
  @param  DestMax                  The maximum number of Destination Ascii\r
                                   char, including terminating null char.\r
  @param  Source                   A pointer to a Null-terminated Ascii string.\r
  @param  Length                   The maximum number of Ascii characters to copy.\r
\r
  @retval RETURN_SUCCESS           String is appended.\r
  @retval RETURN_BAD_BUFFER_SIZE   If DestMax is NOT greater than\r
                                   StrLen(Destination).\r
  @retval RETURN_BUFFER_TOO_SMALL  If (DestMax - StrLen(Destination)) is NOT\r
                                   greater than MIN(StrLen(Source), Length).\r
  @retval RETURN_INVALID_PARAMETER If Destination is NULL.\r
                                   If Source is NULL.\r
                                   If PcdMaximumAsciiStringLength is not zero,\r
                                    and DestMax is greater than \r
                                    PcdMaximumAsciiStringLength.\r
                                   If DestMax is 0.\r
  @retval RETURN_ACCESS_DENIED     If Source and Destination overlap.\r
**/\r
RETURN_STATUS\r
EFIAPI\r
AsciiStrnCatS (\r
  IN OUT CHAR8        *Destination,\r
  IN     UINTN        DestMax,\r
  IN     CONST CHAR8  *Source,\r
  IN     UINTN        Length\r
  )\r
{\r
  UINTN               DestLen;\r
  UINTN               CopyLen;\r
  UINTN               SourceLen;\r
  \r
  //\r
  // Let CopyLen denote the value DestMax - AsciiStrnLenS(Destination, DestMax) upon entry to AsciiStrnCatS.\r
  //\r
  DestLen = AsciiStrnLenS (Destination, DestMax);\r
  CopyLen = DestMax - DestLen;\r
\r
  //\r
  // 1. Neither Destination nor Source shall be a null pointer.\r
  //\r
  SAFE_STRING_CONSTRAINT_CHECK ((Destination != NULL), RETURN_INVALID_PARAMETER);\r
  SAFE_STRING_CONSTRAINT_CHECK ((Source != NULL), RETURN_INVALID_PARAMETER);\r
\r
  //\r
  // 2. Neither DestMax nor Length shall be greater than ASCII_RSIZE_MAX.\r
  //\r
  if (ASCII_RSIZE_MAX != 0) {\r
    SAFE_STRING_CONSTRAINT_CHECK ((DestMax <= ASCII_RSIZE_MAX), RETURN_INVALID_PARAMETER);\r
    SAFE_STRING_CONSTRAINT_CHECK ((Length <= ASCII_RSIZE_MAX), RETURN_INVALID_PARAMETER);\r
  }\r
\r
  //\r
  // 3. DestMax shall not equal zero.\r
  //\r
  SAFE_STRING_CONSTRAINT_CHECK ((DestMax != 0), RETURN_INVALID_PARAMETER);\r
\r
  //\r
  // 4. CopyLen shall not equal zero.\r
  //\r
  SAFE_STRING_CONSTRAINT_CHECK ((CopyLen != 0), RETURN_BAD_BUFFER_SIZE);\r
\r
  //\r
  // 5. If Length is not less than CopyLen, then CopyLen shall be greater than AsciiStrnLenS(Source, CopyLen).\r
  //\r
  SourceLen = AsciiStrnLenS (Source, CopyLen);\r
  if (Length >= CopyLen) {\r
    SAFE_STRING_CONSTRAINT_CHECK ((CopyLen > SourceLen), RETURN_BUFFER_TOO_SMALL);\r
  }\r
\r
  //\r
  // 6. Copying shall not take place between objects that overlap.\r
  //\r
  if (SourceLen > Length) {\r
    SourceLen = Length;\r
  }\r
  SAFE_STRING_CONSTRAINT_CHECK (InternalSafeStringNoAsciiStrOverlap (Destination, DestMax, (CHAR8 *)Source, SourceLen + 1), RETURN_ACCESS_DENIED);\r
\r
  //\r
  // The AsciiStrnCatS function appends not more than Length successive characters (characters\r
  // that follow a null character are not copied) from the array pointed to by Source to the end of\r
  // the string pointed to by Destination. The initial character from Source overwrites the null character at\r
  // the end of Destination. If no null character was copied from Source, then Destination[DestMax-CopyLen+Length] is set to\r
  // a null character.\r
  //\r
  Destination = Destination + DestLen;\r
  while ((*Source != 0) && (SourceLen > 0)) {\r
    *(Destination++) = *(Source++);\r
    SourceLen--;\r
  }\r
  *Destination = 0;\r
\r
  return RETURN_SUCCESS;\r
}\r
\r
/**\r
  Convert a Null-terminated Ascii decimal string to a value of type UINTN.\r
\r
  This function outputs a value of type UINTN by interpreting the contents of\r
  the Ascii string specified by String as a decimal number. The format of the\r
  input Ascii string String is:\r
\r
                  [spaces] [decimal digits].\r
\r
  The valid decimal digit character is in the range [0-9]. The function will\r
  ignore the pad space, which includes spaces or tab characters, before\r
  [decimal digits]. The running zero in the beginning of [decimal digits] will\r
  be ignored. Then, the function stops at the first character that is a not a\r
  valid decimal character or a Null-terminator, whichever one comes first.\r
\r
  If String is NULL, then ASSERT().\r
  If Data is NULL, then ASSERT().\r
  If PcdMaximumAsciiStringLength is not zero, and String contains more than\r
  PcdMaximumAsciiStringLength Ascii characters, not including the\r
  Null-terminator, then ASSERT().\r
\r
  If String has no valid decimal digits in the above format, then 0 is stored\r
  at the location pointed to by Data.\r
  If the number represented by String exceeds the range defined by UINTN, then\r
  MAX_UINTN is stored at the location pointed to by Data.\r
\r
  If EndPointer is not NULL, a pointer to the character that stopped the scan\r
  is stored at the location pointed to by EndPointer. If String has no valid\r
  decimal digits right after the optional pad spaces, the value of String is\r
  stored at the location pointed to by EndPointer.\r
\r
  @param  String                   Pointer to a Null-terminated Ascii string.\r
  @param  EndPointer               Pointer to character that stops scan.\r
  @param  Data                     Pointer to the converted value.\r
\r
  @retval RETURN_SUCCESS           Value is translated from String.\r
  @retval RETURN_INVALID_PARAMETER If String is NULL.\r
                                   If Data is NULL.\r
                                   If PcdMaximumAsciiStringLength is not zero,\r
                                   and String contains more than\r
                                   PcdMaximumAsciiStringLength Ascii\r
                                   characters, not including the\r
                                   Null-terminator.\r
  @retval RETURN_UNSUPPORTED       If the number represented by String exceeds\r
                                   the range defined by UINTN.\r
\r
**/\r
RETURN_STATUS\r
EFIAPI\r
AsciiStrDecimalToUintnS (\r
  IN  CONST CHAR8              *String,\r
  OUT       CHAR8              **EndPointer,  OPTIONAL\r
  OUT       UINTN              *Data\r
  )\r
{\r
  //\r
  // 1. Neither String nor Data shall be a null pointer.\r
  //\r
  SAFE_STRING_CONSTRAINT_CHECK ((String != NULL), RETURN_INVALID_PARAMETER);\r
  SAFE_STRING_CONSTRAINT_CHECK ((Data != NULL), RETURN_INVALID_PARAMETER);\r
\r
  //\r
  // 2. The length of String shall not be greater than ASCII_RSIZE_MAX.\r
  //\r
  if (ASCII_RSIZE_MAX != 0) {\r
    SAFE_STRING_CONSTRAINT_CHECK ((AsciiStrnLenS (String, ASCII_RSIZE_MAX + 1) <= ASCII_RSIZE_MAX), RETURN_INVALID_PARAMETER);\r
  }\r
\r
  if (EndPointer != NULL) {\r
    *EndPointer = (CHAR8 *) String;\r
  }\r
\r
  //\r
  // Ignore the pad spaces (space or tab)\r
  //\r
  while ((*String == ' ') || (*String == '\t')) {\r
    String++;\r
  }\r
\r
  //\r
  // Ignore leading Zeros after the spaces\r
  //\r
  while (*String == '0') {\r
    String++;\r
  }\r
\r
  *Data = 0;\r
\r
  while (InternalAsciiIsDecimalDigitCharacter (*String)) {\r
    //\r
    // If the number represented by String overflows according to the range\r
    // defined by UINTN, then MAX_UINTN is stored in *Data and\r
    // RETURN_UNSUPPORTED is returned.\r
    //\r
    if (*Data > ((MAX_UINTN - (*String - '0')) / 10)) {\r
      *Data = MAX_UINTN;\r
      if (EndPointer != NULL) {\r
        *EndPointer = (CHAR8 *) String;\r
      }\r
      return RETURN_UNSUPPORTED;\r
    }\r
\r
    *Data = *Data * 10 + (*String - '0');\r
    String++;\r
  }\r
\r
  if (EndPointer != NULL) {\r
    *EndPointer = (CHAR8 *) String;\r
  }\r
  return RETURN_SUCCESS;\r
}\r
\r
/**\r
  Convert a Null-terminated Ascii decimal string to a value of type UINT64.\r
\r
  This function outputs a value of type UINT64 by interpreting the contents of\r
  the Ascii string specified by String as a decimal number. The format of the\r
  input Ascii string String is:\r
\r
                  [spaces] [decimal digits].\r
\r
  The valid decimal digit character is in the range [0-9]. The function will\r
  ignore the pad space, which includes spaces or tab characters, before\r
  [decimal digits]. The running zero in the beginning of [decimal digits] will\r
  be ignored. Then, the function stops at the first character that is a not a\r
  valid decimal character or a Null-terminator, whichever one comes first.\r
\r
  If String is NULL, then ASSERT().\r
  If Data is NULL, then ASSERT().\r
  If PcdMaximumAsciiStringLength is not zero, and String contains more than\r
  PcdMaximumAsciiStringLength Ascii characters, not including the\r
  Null-terminator, then ASSERT().\r
\r
  If String has no valid decimal digits in the above format, then 0 is stored\r
  at the location pointed to by Data.\r
  If the number represented by String exceeds the range defined by UINT64, then\r
  MAX_UINT64 is stored at the location pointed to by Data.\r
\r
  If EndPointer is not NULL, a pointer to the character that stopped the scan\r
  is stored at the location pointed to by EndPointer. If String has no valid\r
  decimal digits right after the optional pad spaces, the value of String is\r
  stored at the location pointed to by EndPointer.\r
\r
  @param  String                   Pointer to a Null-terminated Ascii string.\r
  @param  EndPointer               Pointer to character that stops scan.\r
  @param  Data                     Pointer to the converted value.\r
\r
  @retval RETURN_SUCCESS           Value is translated from String.\r
  @retval RETURN_INVALID_PARAMETER If String is NULL.\r
                                   If Data is NULL.\r
                                   If PcdMaximumAsciiStringLength is not zero,\r
                                   and String contains more than\r
                                   PcdMaximumAsciiStringLength Ascii\r
                                   characters, not including the\r
                                   Null-terminator.\r
  @retval RETURN_UNSUPPORTED       If the number represented by String exceeds\r
                                   the range defined by UINT64.\r
\r
**/\r
RETURN_STATUS\r
EFIAPI\r
AsciiStrDecimalToUint64S (\r
  IN  CONST CHAR8              *String,\r
  OUT       CHAR8              **EndPointer,  OPTIONAL\r
  OUT       UINT64             *Data\r
  )\r
{\r
  //\r
  // 1. Neither String nor Data shall be a null pointer.\r
  //\r
  SAFE_STRING_CONSTRAINT_CHECK ((String != NULL), RETURN_INVALID_PARAMETER);\r
  SAFE_STRING_CONSTRAINT_CHECK ((Data != NULL), RETURN_INVALID_PARAMETER);\r
\r
  //\r
  // 2. The length of String shall not be greater than ASCII_RSIZE_MAX.\r
  //\r
  if (ASCII_RSIZE_MAX != 0) {\r
    SAFE_STRING_CONSTRAINT_CHECK ((AsciiStrnLenS (String, ASCII_RSIZE_MAX + 1) <= ASCII_RSIZE_MAX), RETURN_INVALID_PARAMETER);\r
  }\r
\r
  if (EndPointer != NULL) {\r
    *EndPointer = (CHAR8 *) String;\r
  }\r
\r
  //\r
  // Ignore the pad spaces (space or tab)\r
  //\r
  while ((*String == ' ') || (*String == '\t')) {\r
    String++;\r
  }\r
\r
  //\r
  // Ignore leading Zeros after the spaces\r
  //\r
  while (*String == '0') {\r
    String++;\r
  }\r
\r
  *Data = 0;\r
\r
  while (InternalAsciiIsDecimalDigitCharacter (*String)) {\r
    //\r
    // If the number represented by String overflows according to the range\r
    // defined by UINT64, then MAX_UINT64 is stored in *Data and\r
    // RETURN_UNSUPPORTED is returned.\r
    //\r
    if (*Data > DivU64x32 (MAX_UINT64 - (*String - '0'), 10)) {\r
      *Data = MAX_UINT64;\r
      if (EndPointer != NULL) {\r
        *EndPointer = (CHAR8 *) String;\r
      }\r
      return RETURN_UNSUPPORTED;\r
    }\r
\r
    *Data = MultU64x32 (*Data, 10) + (*String - '0');\r
    String++;\r
  }\r
\r
  if (EndPointer != NULL) {\r
    *EndPointer = (CHAR8 *) String;\r
  }\r
  return RETURN_SUCCESS;\r
}\r
\r
/**\r
  Convert a Null-terminated Ascii hexadecimal string to a value of type UINTN.\r
\r
  This function outputs a value of type UINTN by interpreting the contents of\r
  the Ascii string specified by String as a hexadecimal number. The format of\r
  the input Ascii string String is:\r
\r
                  [spaces][zeros][x][hexadecimal digits].\r
\r
  The valid hexadecimal digit character is in the range [0-9], [a-f] and [A-F].\r
  The prefix "0x" is optional. Both "x" and "X" is allowed in "0x" prefix. If\r
  "x" appears in the input string, it must be prefixed with at least one 0. The\r
  function will ignore the pad space, which includes spaces or tab characters,\r
  before [zeros], [x] or [hexadecimal digits]. The running zero before [x] or\r
  [hexadecimal digits] will be ignored. Then, the decoding starts after [x] or\r
  the first valid hexadecimal digit. Then, the function stops at the first\r
  character that is a not a valid hexadecimal character or Null-terminator,\r
  whichever on comes first.\r
\r
  If String is NULL, then ASSERT().\r
  If Data is NULL, then ASSERT().\r
  If PcdMaximumAsciiStringLength is not zero, and String contains more than\r
  PcdMaximumAsciiStringLength Ascii characters, not including the\r
  Null-terminator, then ASSERT().\r
\r
  If String has no valid hexadecimal digits in the above format, then 0 is\r
  stored at the location pointed to by Data.\r
  If the number represented by String exceeds the range defined by UINTN, then\r
  MAX_UINTN is stored at the location pointed to by Data.\r
\r
  If EndPointer is not NULL, a pointer to the character that stopped the scan\r
  is stored at the location pointed to by EndPointer. If String has no valid\r
  hexadecimal digits right after the optional pad spaces, the value of String\r
  is stored at the location pointed to by EndPointer.\r
\r
  @param  String                   Pointer to a Null-terminated Ascii string.\r
  @param  EndPointer               Pointer to character that stops scan.\r
  @param  Data                     Pointer to the converted value.\r
\r
  @retval RETURN_SUCCESS           Value is translated from String.\r
  @retval RETURN_INVALID_PARAMETER If String is NULL.\r
                                   If Data is NULL.\r
                                   If PcdMaximumAsciiStringLength is not zero,\r
                                   and String contains more than\r
                                   PcdMaximumAsciiStringLength Ascii\r
                                   characters, not including the\r
                                   Null-terminator.\r
  @retval RETURN_UNSUPPORTED       If the number represented by String exceeds\r
                                   the range defined by UINTN.\r
\r
**/\r
RETURN_STATUS\r
EFIAPI\r
AsciiStrHexToUintnS (\r
  IN  CONST CHAR8              *String,\r
  OUT       CHAR8              **EndPointer,  OPTIONAL\r
  OUT       UINTN              *Data\r
  )\r
{\r
  //\r
  // 1. Neither String nor Data shall be a null pointer.\r
  //\r
  SAFE_STRING_CONSTRAINT_CHECK ((String != NULL), RETURN_INVALID_PARAMETER);\r
  SAFE_STRING_CONSTRAINT_CHECK ((Data != NULL), RETURN_INVALID_PARAMETER);\r
\r
  //\r
  // 2. The length of String shall not be greater than ASCII_RSIZE_MAX.\r
  //\r
  if (ASCII_RSIZE_MAX != 0) {\r
    SAFE_STRING_CONSTRAINT_CHECK ((AsciiStrnLenS (String, ASCII_RSIZE_MAX + 1) <= ASCII_RSIZE_MAX), RETURN_INVALID_PARAMETER);\r
  }\r
\r
  if (EndPointer != NULL) {\r
    *EndPointer = (CHAR8 *) String;\r
  }\r
\r
  //\r
  // Ignore the pad spaces (space or tab)\r
  //\r
  while ((*String == ' ') || (*String == '\t')) {\r
    String++;\r
  }\r
\r
  //\r
  // Ignore leading Zeros after the spaces\r
  //\r
  while (*String == '0') {\r
    String++;\r
  }\r
\r
  if (InternalBaseLibAsciiToUpper (*String) == 'X') {\r
    if (*(String - 1) != '0') {\r
      *Data = 0;\r
      return RETURN_SUCCESS;\r
    }\r
    //\r
    // Skip the 'X'\r
    //\r
    String++;\r
  }\r
\r
  *Data = 0;\r
\r
  while (InternalAsciiIsHexaDecimalDigitCharacter (*String)) {\r
    //\r
    // If the number represented by String overflows according to the range\r
    // defined by UINTN, then MAX_UINTN is stored in *Data and\r
    // RETURN_UNSUPPORTED is returned.\r
    //\r
    if (*Data > ((MAX_UINTN - InternalAsciiHexCharToUintn (*String)) >> 4)) {\r
      *Data = MAX_UINTN;\r
      if (EndPointer != NULL) {\r
        *EndPointer = (CHAR8 *) String;\r
      }\r
      return RETURN_UNSUPPORTED;\r
    }\r
\r
    *Data = (*Data << 4) + InternalAsciiHexCharToUintn (*String);\r
    String++;\r
  }\r
\r
  if (EndPointer != NULL) {\r
    *EndPointer = (CHAR8 *) String;\r
  }\r
  return RETURN_SUCCESS;\r
}\r
\r
/**\r
  Convert a Null-terminated Ascii hexadecimal string to a value of type UINT64.\r
\r
  This function outputs a value of type UINT64 by interpreting the contents of\r
  the Ascii string specified by String as a hexadecimal number. The format of\r
  the input Ascii string String is:\r
\r
                  [spaces][zeros][x][hexadecimal digits].\r
\r
  The valid hexadecimal digit character is in the range [0-9], [a-f] and [A-F].\r
  The prefix "0x" is optional. Both "x" and "X" is allowed in "0x" prefix. If\r
  "x" appears in the input string, it must be prefixed with at least one 0. The\r
  function will ignore the pad space, which includes spaces or tab characters,\r
  before [zeros], [x] or [hexadecimal digits]. The running zero before [x] or\r
  [hexadecimal digits] will be ignored. Then, the decoding starts after [x] or\r
  the first valid hexadecimal digit. Then, the function stops at the first\r
  character that is a not a valid hexadecimal character or Null-terminator,\r
  whichever on comes first.\r
\r
  If String is NULL, then ASSERT().\r
  If Data is NULL, then ASSERT().\r
  If PcdMaximumAsciiStringLength is not zero, and String contains more than\r
  PcdMaximumAsciiStringLength Ascii characters, not including the\r
  Null-terminator, then ASSERT().\r
\r
  If String has no valid hexadecimal digits in the above format, then 0 is\r
  stored at the location pointed to by Data.\r
  If the number represented by String exceeds the range defined by UINT64, then\r
  MAX_UINT64 is stored at the location pointed to by Data.\r
\r
  If EndPointer is not NULL, a pointer to the character that stopped the scan\r
  is stored at the location pointed to by EndPointer. If String has no valid\r
  hexadecimal digits right after the optional pad spaces, the value of String\r
  is stored at the location pointed to by EndPointer.\r
\r
  @param  String                   Pointer to a Null-terminated Ascii string.\r
  @param  EndPointer               Pointer to character that stops scan.\r
  @param  Data                     Pointer to the converted value.\r
\r
  @retval RETURN_SUCCESS           Value is translated from String.\r
  @retval RETURN_INVALID_PARAMETER If String is NULL.\r
                                   If Data is NULL.\r
                                   If PcdMaximumAsciiStringLength is not zero,\r
                                   and String contains more than\r
                                   PcdMaximumAsciiStringLength Ascii\r
                                   characters, not including the\r
                                   Null-terminator.\r
  @retval RETURN_UNSUPPORTED       If the number represented by String exceeds\r
                                   the range defined by UINT64.\r
\r
**/\r
RETURN_STATUS\r
EFIAPI\r
AsciiStrHexToUint64S (\r
  IN  CONST CHAR8              *String,\r
  OUT       CHAR8              **EndPointer,  OPTIONAL\r
  OUT       UINT64             *Data\r
  )\r
{\r
  //\r
  // 1. Neither String nor Data shall be a null pointer.\r
  //\r
  SAFE_STRING_CONSTRAINT_CHECK ((String != NULL), RETURN_INVALID_PARAMETER);\r
  SAFE_STRING_CONSTRAINT_CHECK ((Data != NULL), RETURN_INVALID_PARAMETER);\r
\r
  //\r
  // 2. The length of String shall not be greater than ASCII_RSIZE_MAX.\r
  //\r
  if (ASCII_RSIZE_MAX != 0) {\r
    SAFE_STRING_CONSTRAINT_CHECK ((AsciiStrnLenS (String, ASCII_RSIZE_MAX + 1) <= ASCII_RSIZE_MAX), RETURN_INVALID_PARAMETER);\r
  }\r
\r
  if (EndPointer != NULL) {\r
    *EndPointer = (CHAR8 *) String;\r
  }\r
\r
  //\r
  // Ignore the pad spaces (space or tab)\r
  //\r
  while ((*String == ' ') || (*String == '\t')) {\r
    String++;\r
  }\r
\r
  //\r
  // Ignore leading Zeros after the spaces\r
  //\r
  while (*String == '0') {\r
    String++;\r
  }\r
\r
  if (InternalBaseLibAsciiToUpper (*String) == 'X') {\r
    if (*(String - 1) != '0') {\r
      *Data = 0;\r
      return RETURN_SUCCESS;\r
    }\r
    //\r
    // Skip the 'X'\r
    //\r
    String++;\r
  }\r
\r
  *Data = 0;\r
\r
  while (InternalAsciiIsHexaDecimalDigitCharacter (*String)) {\r
    //\r
    // If the number represented by String overflows according to the range\r
    // defined by UINT64, then MAX_UINT64 is stored in *Data and\r
    // RETURN_UNSUPPORTED is returned.\r
    //\r
    if (*Data > RShiftU64 (MAX_UINT64 - InternalAsciiHexCharToUintn (*String), 4)) {\r
      *Data = MAX_UINT64;\r
      if (EndPointer != NULL) {\r
        *EndPointer = (CHAR8 *) String;\r
      }\r
      return RETURN_UNSUPPORTED;\r
    }\r
\r
    *Data = LShiftU64 (*Data, 4) + InternalAsciiHexCharToUintn (*String);\r
    String++;\r
  }\r
\r
  if (EndPointer != NULL) {\r
    *EndPointer = (CHAR8 *) String;\r
  }\r
  return RETURN_SUCCESS;\r
}\r
\r
/**\r
  Convert a Null-terminated Unicode string to a Null-terminated\r
  ASCII string.\r
\r
  This function is similar to AsciiStrCpyS.\r
\r
  This function converts the content of the Unicode string Source\r
  to the ASCII string Destination by copying the lower 8 bits of\r
  each Unicode character. The function terminates the ASCII string\r
  Destination by appending a Null-terminator character at the end.\r
\r
  The caller is responsible to make sure Destination points to a buffer with size\r
  equal or greater than ((StrLen (Source) + 1) * sizeof (CHAR8)) in bytes.\r
\r
  If any Unicode characters in Source contain non-zero value in\r
  the upper 8 bits, then ASSERT().\r
\r
  If Source is not aligned on a 16-bit boundary, then ASSERT().\r
  If an error would be returned, then the function will also ASSERT().\r
\r
  If an error is returned, then the Destination is unmodified.\r
\r
  @param  Source        The pointer to a Null-terminated Unicode string.\r
  @param  Destination   The pointer to a Null-terminated ASCII string.\r
  @param  DestMax       The maximum number of Destination Ascii\r
                        char, including terminating null char.\r
\r
  @retval RETURN_SUCCESS           String is converted.\r
  @retval RETURN_BUFFER_TOO_SMALL  If DestMax is NOT greater than StrLen(Source).\r
  @retval RETURN_INVALID_PARAMETER If Destination is NULL.\r
                                   If Source is NULL.\r
                                   If PcdMaximumAsciiStringLength is not zero,\r
                                    and DestMax is greater than\r
                                    PcdMaximumAsciiStringLength.\r
                                   If PcdMaximumUnicodeStringLength is not zero,\r
                                    and DestMax is greater than\r
                                    PcdMaximumUnicodeStringLength.\r
                                   If DestMax is 0.\r
  @retval RETURN_ACCESS_DENIED     If Source and Destination overlap.\r
\r
**/\r
RETURN_STATUS\r
EFIAPI\r
UnicodeStrToAsciiStrS (\r
  IN      CONST CHAR16              *Source,\r
  OUT     CHAR8                     *Destination,\r
  IN      UINTN                     DestMax\r
  )\r
{\r
  UINTN            SourceLen;\r
\r
  ASSERT (((UINTN) Source & BIT0) == 0);\r
\r
  //\r
  // 1. Neither Destination nor Source shall be a null pointer.\r
  //\r
  SAFE_STRING_CONSTRAINT_CHECK ((Destination != NULL), RETURN_INVALID_PARAMETER);\r
  SAFE_STRING_CONSTRAINT_CHECK ((Source != NULL), RETURN_INVALID_PARAMETER);\r
\r
  //\r
  // 2. DestMax shall not be greater than ASCII_RSIZE_MAX or RSIZE_MAX.\r
  //\r
  if (ASCII_RSIZE_MAX != 0) {\r
    SAFE_STRING_CONSTRAINT_CHECK ((DestMax <= ASCII_RSIZE_MAX), RETURN_INVALID_PARAMETER);\r
  }\r
  if (RSIZE_MAX != 0) {\r
    SAFE_STRING_CONSTRAINT_CHECK ((DestMax <= RSIZE_MAX), RETURN_INVALID_PARAMETER);\r
  }\r
\r
  //\r
  // 3. DestMax shall not equal zero.\r
  //\r
  SAFE_STRING_CONSTRAINT_CHECK ((DestMax != 0), RETURN_INVALID_PARAMETER);\r
\r
  //\r
  // 4. DestMax shall be greater than StrnLenS (Source, DestMax).\r
  //\r
  SourceLen = StrnLenS (Source, DestMax);\r
  SAFE_STRING_CONSTRAINT_CHECK ((DestMax > SourceLen), RETURN_BUFFER_TOO_SMALL);\r
\r
  //\r
  // 5. Copying shall not take place between objects that overlap.\r
  //\r
  SAFE_STRING_CONSTRAINT_CHECK (!InternalSafeStringIsOverlap (Destination, DestMax, (VOID *)Source, (SourceLen + 1) * sizeof(CHAR16)), RETURN_ACCESS_DENIED);\r
\r
  //\r
  // convert string\r
  //\r
  while (*Source != '\0') {\r
    //\r
    // If any Unicode characters in Source contain\r
    // non-zero value in the upper 8 bits, then ASSERT().\r
    //\r
    ASSERT (*Source < 0x100);\r
    *(Destination++) = (CHAR8) *(Source++);\r
  }\r
  *Destination = '\0';\r
\r
  return RETURN_SUCCESS;\r
}\r
\r
/**\r
  Convert not more than Length successive characters from a Null-terminated\r
  Unicode string to a Null-terminated Ascii string. If no null char is copied\r
  from Source, then Destination[Length] is always set to null.\r
\r
  This function converts not more than Length successive characters from the\r
  Unicode string Source to the Ascii string Destination by copying the lower 8\r
  bits of each Unicode character. The function terminates the Ascii string\r
  Destination by appending a Null-terminator character at the end.\r
\r
  The caller is responsible to make sure Destination points to a buffer with\r
  size not smaller than ((MIN(StrLen(Source), Length) + 1) * sizeof (CHAR8))\r
  in bytes.\r
\r
  If any Unicode characters in Source contain non-zero value in the upper 8\r
  bits, then ASSERT().\r
  If Source is not aligned on a 16-bit boundary, then ASSERT().\r
  If an error would be returned, then the function will also ASSERT().\r
\r
  If an error is returned, then Destination and DestinationLength are\r
  unmodified.\r
\r
  @param  Source             The pointer to a Null-terminated Unicode string.\r
  @param  Length             The maximum number of Unicode characters to\r
                             convert.\r
  @param  Destination        The pointer to a Null-terminated Ascii string.\r
  @param  DestMax            The maximum number of Destination Ascii char,\r
                             including terminating null char.\r
  @param  DestinationLength  The number of Unicode characters converted.\r
\r
  @retval RETURN_SUCCESS            String is converted.\r
  @retval RETURN_INVALID_PARAMETER  If Destination is NULL.\r
                                    If Source is NULL.\r
                                    If DestinationLength is NULL.\r
                                    If PcdMaximumAsciiStringLength is not zero,\r
                                    and Length or DestMax is greater than\r
                                    PcdMaximumAsciiStringLength.\r
                                    If PcdMaximumUnicodeStringLength is not\r
                                    zero, and Length or DestMax is greater than\r
                                    PcdMaximumUnicodeStringLength.\r
                                    If DestMax is 0.\r
  @retval RETURN_BUFFER_TOO_SMALL   If DestMax is NOT greater than\r
                                    MIN(StrLen(Source), Length).\r
  @retval RETURN_ACCESS_DENIED      If Source and Destination overlap.\r
\r
**/\r
RETURN_STATUS\r
EFIAPI\r
UnicodeStrnToAsciiStrS (\r
  IN      CONST CHAR16              *Source,\r
  IN      UINTN                     Length,\r
  OUT     CHAR8                     *Destination,\r
  IN      UINTN                     DestMax,\r
  OUT     UINTN                     *DestinationLength\r
  )\r
{\r
  UINTN            SourceLen;\r
\r
  ASSERT (((UINTN) Source & BIT0) == 0);\r
\r
  //\r
  // 1. None of Destination, Source or DestinationLength shall be a null\r
  // pointer.\r
  //\r
  SAFE_STRING_CONSTRAINT_CHECK ((Destination != NULL), RETURN_INVALID_PARAMETER);\r
  SAFE_STRING_CONSTRAINT_CHECK ((Source != NULL), RETURN_INVALID_PARAMETER);\r
  SAFE_STRING_CONSTRAINT_CHECK ((DestinationLength != NULL), RETURN_INVALID_PARAMETER);\r
\r
  //\r
  // 2. Neither Length nor DestMax shall be greater than ASCII_RSIZE_MAX or\r
  // RSIZE_MAX.\r
  //\r
  if (ASCII_RSIZE_MAX != 0) {\r
    SAFE_STRING_CONSTRAINT_CHECK ((Length <= ASCII_RSIZE_MAX), RETURN_INVALID_PARAMETER);\r
    SAFE_STRING_CONSTRAINT_CHECK ((DestMax <= ASCII_RSIZE_MAX), RETURN_INVALID_PARAMETER);\r
  }\r
  if (RSIZE_MAX != 0) {\r
    SAFE_STRING_CONSTRAINT_CHECK ((Length <= RSIZE_MAX), RETURN_INVALID_PARAMETER);\r
    SAFE_STRING_CONSTRAINT_CHECK ((DestMax <= RSIZE_MAX), RETURN_INVALID_PARAMETER);\r
  }\r
\r
  //\r
  // 3. DestMax shall not equal zero.\r
  //\r
  SAFE_STRING_CONSTRAINT_CHECK ((DestMax != 0), RETURN_INVALID_PARAMETER);\r
\r
  //\r
  // 4. If Length is not less than DestMax, then DestMax shall be greater than\r
  // StrnLenS(Source, DestMax).\r
  //\r
  SourceLen = StrnLenS (Source, DestMax);\r
  if (Length >= DestMax) {\r
    SAFE_STRING_CONSTRAINT_CHECK ((DestMax > SourceLen), RETURN_BUFFER_TOO_SMALL);\r
  }\r
\r
  //\r
  // 5. Copying shall not take place between objects that overlap.\r
  //\r
  if (SourceLen > Length) {\r
    SourceLen = Length;\r
  }\r
  SAFE_STRING_CONSTRAINT_CHECK (!InternalSafeStringIsOverlap (Destination, DestMax, (VOID *)Source, (SourceLen + 1) * sizeof(CHAR16)), RETURN_ACCESS_DENIED);\r
\r
  *DestinationLength = 0;\r
\r
  //\r
  // Convert string\r
  //\r
  while ((*Source != 0) && (SourceLen > 0)) {\r
    //\r
    // If any Unicode characters in Source contain non-zero value in the upper\r
    // 8 bits, then ASSERT().\r
    //\r
    ASSERT (*Source < 0x100);\r
    *(Destination++) = (CHAR8) *(Source++);\r
    SourceLen--;\r
    (*DestinationLength)++;\r
  }\r
  *Destination = 0;\r
\r
  return RETURN_SUCCESS;\r
}\r
\r
/**\r
  Convert one Null-terminated ASCII string to a Null-terminated\r
  Unicode string.\r
\r
  This function is similar to StrCpyS.\r
\r
  This function converts the contents of the ASCII string Source to the Unicode\r
  string Destination. The function terminates the Unicode string Destination by\r
  appending a Null-terminator character at the end.\r
\r
  The caller is responsible to make sure Destination points to a buffer with size\r
  equal or greater than ((AsciiStrLen (Source) + 1) * sizeof (CHAR16)) in bytes.\r
\r
  If Destination is not aligned on a 16-bit boundary, then ASSERT().\r
  If an error would be returned, then the function will also ASSERT().\r
\r
  If an error is returned, then the Destination is unmodified.\r
\r
  @param  Source        The pointer to a Null-terminated ASCII string.\r
  @param  Destination   The pointer to a Null-terminated Unicode string.\r
  @param  DestMax       The maximum number of Destination Unicode\r
                        char, including terminating null char.\r
\r
  @retval RETURN_SUCCESS           String is converted.\r
  @retval RETURN_BUFFER_TOO_SMALL  If DestMax is NOT greater than StrLen(Source).\r
  @retval RETURN_INVALID_PARAMETER If Destination is NULL.\r
                                   If Source is NULL.\r
                                   If PcdMaximumUnicodeStringLength is not zero,\r
                                    and DestMax is greater than\r
                                    PcdMaximumUnicodeStringLength.\r
                                   If PcdMaximumAsciiStringLength is not zero,\r
                                    and DestMax is greater than\r
                                    PcdMaximumAsciiStringLength.\r
                                   If DestMax is 0.\r
  @retval RETURN_ACCESS_DENIED     If Source and Destination overlap.\r
\r
**/\r
RETURN_STATUS\r
EFIAPI\r
AsciiStrToUnicodeStrS (\r
  IN      CONST CHAR8               *Source,\r
  OUT     CHAR16                    *Destination,\r
  IN      UINTN                     DestMax\r
  )\r
{\r
  UINTN            SourceLen;\r
\r
  ASSERT (((UINTN) Destination & BIT0) == 0);\r
\r
  //\r
  // 1. Neither Destination nor Source shall be a null pointer.\r
  //\r
  SAFE_STRING_CONSTRAINT_CHECK ((Destination != NULL), RETURN_INVALID_PARAMETER);\r
  SAFE_STRING_CONSTRAINT_CHECK ((Source != NULL), RETURN_INVALID_PARAMETER);\r
\r
  //\r
  // 2. DestMax shall not be greater than RSIZE_MAX or ASCII_RSIZE_MAX.\r
  //\r
  if (RSIZE_MAX != 0) {\r
    SAFE_STRING_CONSTRAINT_CHECK ((DestMax <= RSIZE_MAX), RETURN_INVALID_PARAMETER);\r
  }\r
  if (ASCII_RSIZE_MAX != 0) {\r
    SAFE_STRING_CONSTRAINT_CHECK ((DestMax <= ASCII_RSIZE_MAX), RETURN_INVALID_PARAMETER);\r
  }\r
\r
  //\r
  // 3. DestMax shall not equal zero.\r
  //\r
  SAFE_STRING_CONSTRAINT_CHECK ((DestMax != 0), RETURN_INVALID_PARAMETER);\r
\r
  //\r
  // 4. DestMax shall be greater than AsciiStrnLenS(Source, DestMax).\r
  //\r
  SourceLen = AsciiStrnLenS (Source, DestMax);\r
  SAFE_STRING_CONSTRAINT_CHECK ((DestMax > SourceLen), RETURN_BUFFER_TOO_SMALL);\r
\r
  //\r
  // 5. Copying shall not take place between objects that overlap.\r
  //\r
  SAFE_STRING_CONSTRAINT_CHECK (!InternalSafeStringIsOverlap (Destination, DestMax * sizeof(CHAR16), (VOID *)Source, SourceLen + 1), RETURN_ACCESS_DENIED);\r
\r
  //\r
  // Convert string\r
  //\r
  while (*Source != '\0') {\r
    *(Destination++) = (CHAR16)*(Source++);\r
  }\r
  *Destination = '\0';\r
\r
  return RETURN_SUCCESS;\r
}\r
\r
/**\r
  Convert not more than Length successive characters from a Null-terminated\r
  Ascii string to a Null-terminated Unicode string. If no null char is copied\r
  from Source, then Destination[Length] is always set to null.\r
\r
  This function converts not more than Length successive characters from the\r
  Ascii string Source to the Unicode string Destination. The function\r
  terminates the Unicode string Destination by appending a Null-terminator\r
  character at the end.\r
\r
  The caller is responsible to make sure Destination points to a buffer with\r
  size not smaller than\r
  ((MIN(AsciiStrLen(Source), Length) + 1) * sizeof (CHAR8)) in bytes.\r
\r
  If Destination is not aligned on a 16-bit boundary, then ASSERT().\r
  If an error would be returned, then the function will also ASSERT().\r
\r
  If an error is returned, then Destination and DestinationLength are\r
  unmodified.\r
\r
  @param  Source             The pointer to a Null-terminated Ascii string.\r
  @param  Length             The maximum number of Ascii characters to convert.\r
  @param  Destination        The pointer to a Null-terminated Unicode string.\r
  @param  DestMax            The maximum number of Destination Unicode char,\r
                             including terminating null char.\r
  @param  DestinationLength  The number of Ascii characters converted.\r
\r
  @retval RETURN_SUCCESS            String is converted.\r
  @retval RETURN_INVALID_PARAMETER  If Destination is NULL.\r
                                    If Source is NULL.\r
                                    If DestinationLength is NULL.\r
                                    If PcdMaximumUnicodeStringLength is not\r
                                    zero, and Length or DestMax is greater than\r
                                    PcdMaximumUnicodeStringLength.\r
                                    If PcdMaximumAsciiStringLength is not zero,\r
                                    and Length or DestMax is greater than\r
                                    PcdMaximumAsciiStringLength.\r
                                    If DestMax is 0.\r
  @retval RETURN_BUFFER_TOO_SMALL   If DestMax is NOT greater than\r
                                    MIN(AsciiStrLen(Source), Length).\r
  @retval RETURN_ACCESS_DENIED      If Source and Destination overlap.\r
\r
**/\r
RETURN_STATUS\r
EFIAPI\r
AsciiStrnToUnicodeStrS (\r
  IN      CONST CHAR8               *Source,\r
  IN      UINTN                     Length,\r
  OUT     CHAR16                    *Destination,\r
  IN      UINTN                     DestMax,\r
  OUT     UINTN                     *DestinationLength\r
  )\r
{\r
  UINTN            SourceLen;\r
\r
  ASSERT (((UINTN) Destination & BIT0) == 0);\r
\r
  //\r
  // 1. None of Destination, Source or DestinationLength shall be a null\r
  // pointer.\r
  //\r
  SAFE_STRING_CONSTRAINT_CHECK ((Destination != NULL), RETURN_INVALID_PARAMETER);\r
  SAFE_STRING_CONSTRAINT_CHECK ((Source != NULL), RETURN_INVALID_PARAMETER);\r
  SAFE_STRING_CONSTRAINT_CHECK ((DestinationLength != NULL), RETURN_INVALID_PARAMETER);\r
\r
  //\r
  // 2. Neither Length nor DestMax shall be greater than ASCII_RSIZE_MAX or\r
  // RSIZE_MAX.\r
  //\r
  if (RSIZE_MAX != 0) {\r
    SAFE_STRING_CONSTRAINT_CHECK ((Length <= RSIZE_MAX), RETURN_INVALID_PARAMETER);\r
    SAFE_STRING_CONSTRAINT_CHECK ((DestMax <= RSIZE_MAX), RETURN_INVALID_PARAMETER);\r
  }\r
  if (ASCII_RSIZE_MAX != 0) {\r
    SAFE_STRING_CONSTRAINT_CHECK ((Length <= ASCII_RSIZE_MAX), RETURN_INVALID_PARAMETER);\r
    SAFE_STRING_CONSTRAINT_CHECK ((DestMax <= ASCII_RSIZE_MAX), RETURN_INVALID_PARAMETER);\r
  }\r
\r
  //\r
  // 3. DestMax shall not equal zero.\r
  //\r
  SAFE_STRING_CONSTRAINT_CHECK ((DestMax != 0), RETURN_INVALID_PARAMETER);\r
\r
  //\r
  // 4. If Length is not less than DestMax, then DestMax shall be greater than\r
  // AsciiStrnLenS(Source, DestMax).\r
  //\r
  SourceLen = AsciiStrnLenS (Source, DestMax);\r
  if (Length >= DestMax) {\r
    SAFE_STRING_CONSTRAINT_CHECK ((DestMax > SourceLen), RETURN_BUFFER_TOO_SMALL);\r
  }\r
\r
  //\r
  // 5. Copying shall not take place between objects that overlap.\r
  //\r
  if (SourceLen > Length) {\r
    SourceLen = Length;\r
  }\r
  SAFE_STRING_CONSTRAINT_CHECK (!InternalSafeStringIsOverlap (Destination, DestMax * sizeof(CHAR16), (VOID *)Source, SourceLen + 1), RETURN_ACCESS_DENIED);\r
\r
  *DestinationLength = 0;\r
\r
  //\r
  // Convert string\r
  //\r
  while ((*Source != 0) && (SourceLen > 0)) {\r
    *(Destination++) = (CHAR16)*(Source++);\r
    SourceLen--;\r
    (*DestinationLength)++;\r
  }\r
  *Destination = 0;\r
\r
  return RETURN_SUCCESS;\r
}\r