/** @file

  Unicode and ASCII string primitives.

  Copyright (c) 2006 - 2018, Intel Corporation. All rights reserved.<BR>

  SPDX-License-Identifier: BSD-2-Clause-Patent

**/

#include <Base.h>

#include <Library/BaseLib.h>

#include <Library/DebugLib.h>

/**

  Returns the length of a Null-terminated Unicode string.

  This function returns the number of Unicode characters in the Null-terminated

  Unicode string specified by String.

  If String is NULL, then ASSERT().

  If String is not aligned on a 16-bit boundary, then ASSERT().

  If PcdMaximumUnicodeStringLength is not zero, and String contains more than

  PcdMaximumUnicodeStringLength Unicode characters, not including the

  Null-terminator, then ASSERT().

  @param  String  A pointer to a Null-terminated Unicode string.

  @return The length of String.

**/

UINTN

EFIAPI

StrLen (

  IN      CONST CHAR16              *String

  )

{

  UINTN                             Length;

  ASSERT (String != NULL);

  ASSERT (((UINTN) String & BIT0) == 0);

  for (Length = 0; *String != L'\0'; String++, Length++) {

    //

    // If PcdMaximumUnicodeStringLength is not zero,

    // length should not more than PcdMaximumUnicodeStringLength

    //

  }

  return Length;

}

/**

  Returns the size of a Null-terminated Unicode string in bytes, including the

  Null terminator.

  This function returns the size, in bytes, of the Null-terminated Unicode string

  specified by String.

  If String is NULL, then ASSERT().

  If String is not aligned on a 16-bit boundary, then ASSERT().

  If PcdMaximumUnicodeStringLength is not zero, and String contains more than

  PcdMaximumUnicodeStringLength Unicode characters, not including the

  Null-terminator, then ASSERT().

  @param  String  A pointer to a Null-terminated Unicode string.

  @return The size of String.

**/

UINTN

EFIAPI

StrSize (

  IN      CONST CHAR16              *String

  )

{

  return (StrLen (String) + 1) * sizeof (*String);

}

/**

  Compares two Null-terminated Unicode strings, and returns the difference

  between the first mismatched Unicode characters.

  This function compares the Null-terminated Unicode string FirstString to the

  Null-terminated Unicode string SecondString. If FirstString is identical to

  SecondString, then 0 is returned. Otherwise, the value returned is the first

  mismatched Unicode character in SecondString subtracted from the first

  mismatched Unicode character in FirstString.

  If FirstString is NULL, then ASSERT().

  If FirstString is not aligned on a 16-bit boundary, then ASSERT().

  If SecondString is NULL, then ASSERT().

  If SecondString is not aligned on a 16-bit boundary, then ASSERT().

  If PcdMaximumUnicodeStringLength is not zero, and FirstString contains more

  than PcdMaximumUnicodeStringLength Unicode characters, not including the

  Null-terminator, then ASSERT().

  If PcdMaximumUnicodeStringLength is not zero, and SecondString contains more

  than PcdMaximumUnicodeStringLength Unicode characters, not including the

  Null-terminator, then ASSERT().

  @param  FirstString   A pointer to a Null-terminated Unicode string.

  @param  SecondString  A pointer to a Null-terminated Unicode string.

  @retval 0      FirstString is identical to SecondString.

  @return others FirstString is not identical to SecondString.

**/

INTN

EFIAPI

StrCmp (

  IN      CONST CHAR16              *FirstString,

  IN      CONST CHAR16              *SecondString

  )

{

  //

  // ASSERT both strings are less long than PcdMaximumUnicodeStringLength

  //

  ASSERT (StrSize (FirstString) != 0);

  ASSERT (StrSize (SecondString) != 0);

  while ((*FirstString != L'\0') && (*FirstString == *SecondString)) {

    FirstString++;

    SecondString++;

  }

  return *FirstString - *SecondString;

}

/**

  Compares up to a specified length the contents of two Null-terminated Unicode strings,

  and returns the difference between the first mismatched Unicode characters.

  This function compares the Null-terminated Unicode string FirstString to the

  Null-terminated Unicode string SecondString. At most, Length Unicode

  characters will be compared. If Length is 0, then 0 is returned. If

  FirstString is identical to SecondString, then 0 is returned. Otherwise, the

  value returned is the first mismatched Unicode character in SecondString

  subtracted from the first mismatched Unicode character in FirstString.

  If Length > 0 and FirstString is NULL, then ASSERT().

  If Length > 0 and FirstString is not aligned on a 16-bit boundary, then ASSERT().

  If Length > 0 and SecondString is NULL, then ASSERT().

  If Length > 0 and SecondString is not aligned on a 16-bit boundary, then ASSERT().

  If PcdMaximumUnicodeStringLength is not zero, and Length is greater than

  PcdMaximumUnicodeStringLength, then ASSERT().

  If PcdMaximumUnicodeStringLength is not zero, and FirstString contains more than

  PcdMaximumUnicodeStringLength Unicode characters, not including the Null-terminator,

  then ASSERT().

  If PcdMaximumUnicodeStringLength is not zero, and SecondString contains more than

  PcdMaximumUnicodeStringLength Unicode characters, not including the Null-terminator,

  then ASSERT().

  @param  FirstString   A pointer to a Null-terminated Unicode string.

  @param  SecondString  A pointer to a Null-terminated Unicode string.

  @param  Length        The maximum number of Unicode characters to compare.

  @retval 0      FirstString is identical to SecondString.

  @return others FirstString is not identical to SecondString.

**/

INTN

EFIAPI

StrnCmp (

  IN      CONST CHAR16              *FirstString,

  IN      CONST CHAR16              *SecondString,

  IN      UINTN                     Length

  )

{

  if (Length == 0) {

    return 0;

  }

  //

  // ASSERT both strings are less long than PcdMaximumUnicodeStringLength.

  // Length tests are performed inside StrLen().

  //

  ASSERT (StrSize (FirstString) != 0);

  ASSERT (StrSize (SecondString) != 0);

  while ((*FirstString != L'\0') &&

         (*SecondString != L'\0') &&

         (*FirstString == *SecondString) &&

         (Length > 1)) {

    FirstString++;

    SecondString++;

    Length--;

  }

  return *FirstString - *SecondString;

}

/**

  Returns the first occurrence of a Null-terminated Unicode sub-string

  in a Null-terminated Unicode string.

  This function scans the contents of the Null-terminated Unicode string

  specified by String and returns the first occurrence of SearchString.

  If SearchString is not found in String, then NULL is returned.  If

  the length of SearchString is zero, then String is

  returned.

  If String is NULL, then ASSERT().

  If String is not aligned on a 16-bit boundary, then ASSERT().

  If SearchString is NULL, then ASSERT().

  If SearchString is not aligned on a 16-bit boundary, then ASSERT().

  If PcdMaximumUnicodeStringLength is not zero, and SearchString

  or String contains more than PcdMaximumUnicodeStringLength Unicode

  characters, not including the Null-terminator, then ASSERT().

  @param  String          A pointer to a Null-terminated Unicode string.

  @param  SearchString    A pointer to a Null-terminated Unicode string to search for.

  @retval NULL            If the SearchString does not appear in String.

  @return others          If there is a match.

**/

CHAR16 *

EFIAPI

StrStr (

  IN      CONST CHAR16              *String,

  IN      CONST CHAR16              *SearchString

  )

{

  CONST CHAR16 *FirstMatch;

  CONST CHAR16 *SearchStringTmp;

  //

  // ASSERT both strings are less long than PcdMaximumUnicodeStringLength.

  // Length tests are performed inside StrLen().

  //

  ASSERT (StrSize (String) != 0);

  ASSERT (StrSize (SearchString) != 0);

  if (*SearchString == L'\0') {

    return (CHAR16 *) String;

  }

  while (*String != L'\0') {

    SearchStringTmp = SearchString;

    FirstMatch = String;

    while ((*String == *SearchStringTmp)

            && (*String != L'\0')) {

      String++;

      SearchStringTmp++;

    }

    if (*SearchStringTmp == L'\0') {

      return (CHAR16 *) FirstMatch;

    }

    if (*String == L'\0') {

      return NULL;

    }

    String = FirstMatch + 1;

  }

  return NULL;

}

/**

  Check if a Unicode character is a decimal character.

  This internal function checks if a Unicode character is a

  decimal character. The valid decimal character is from

  L'0' to L'9'.

  @param  Char  The character to check against.

  @retval TRUE  If the Char is a decmial character.

  @retval FALSE If the Char is not a decmial character.

**/

BOOLEAN

EFIAPI

InternalIsDecimalDigitCharacter (

  IN      CHAR16                    Char

  )

{

  return (BOOLEAN) (Char >= L'0' && Char <= L'9');

}

/**

  Convert a Unicode character to upper case only if

  it maps to a valid small-case ASCII character.

  This internal function only deal with Unicode character

  which maps to a valid small-case ASCII character, i.e.

  L'a' to L'z'. For other Unicode character, the input character

  is returned directly.

  @param  Char  The character to convert.

  @retval LowerCharacter   If the Char is with range L'a' to L'z'.

  @retval Unchanged        Otherwise.

**/

CHAR16

EFIAPI

InternalCharToUpper (

  IN      CHAR16                    Char

  )

{

  if (Char >= L'a' && Char <= L'z') {

    return (CHAR16) (Char - (L'a' - L'A'));

  }

  return Char;

}

/**

  Convert a Unicode character to numerical value.

  This internal function only deal with Unicode character

  which maps to a valid hexadecimal ASII character, i.e.

  L'0' to L'9', L'a' to L'f' or L'A' to L'F'. For other

  Unicode character, the value returned does not make sense.

  @param  Char  The character to convert.

  @return The numerical value converted.

**/

UINTN

EFIAPI

InternalHexCharToUintn (

  IN      CHAR16                    Char

  )

{

  if (InternalIsDecimalDigitCharacter (Char)) {

    return Char - L'0';

  }

  return (10 + InternalCharToUpper (Char) - L'A');

}

/**

  Check if a Unicode character is a hexadecimal character.

  This internal function checks if a Unicode character is a

  decimal character.  The valid hexadecimal character is

  L'0' to L'9', L'a' to L'f', or L'A' to L'F'.

  @param  Char  The character to check against.

  @retval TRUE  If the Char is a hexadecmial character.

  @retval FALSE If the Char is not a hexadecmial character.

**/

BOOLEAN

EFIAPI

InternalIsHexaDecimalDigitCharacter (

  IN      CHAR16                    Char

  )

{

  return (BOOLEAN) (InternalIsDecimalDigitCharacter (Char) ||

    (Char >= L'A' && Char <= L'F') ||

    (Char >= L'a' && Char <= L'f'));

}

/**

  Convert a Null-terminated Unicode decimal string to a value of

  type UINTN.

  This function returns a value of type UINTN by interpreting the contents

  of the Unicode string specified by String as a decimal number. The format

  of the input Unicode string String is:

                  [spaces] [decimal digits].

  The valid decimal digit character is in the range [0-9]. The

  function will ignore the pad space, which includes spaces or

  tab characters, before [decimal digits]. The running zero in the

  beginning of [decimal digits] will be ignored. Then, the function

  stops at the first character that is a not a valid decimal character

  or a Null-terminator, whichever one comes first.

  If String is NULL, then ASSERT().

  If String is not aligned in a 16-bit boundary, then ASSERT().

  If String has only pad spaces, then 0 is returned.

  If String has no pad spaces or valid decimal digits,

  then 0 is returned.

  If the number represented by String overflows according

  to the range defined by UINTN, then MAX_UINTN is returned.

  If PcdMaximumUnicodeStringLength is not zero, and String contains

  more than PcdMaximumUnicodeStringLength Unicode characters, not including

  the Null-terminator, then ASSERT().

  @param  String      A pointer to a Null-terminated Unicode string.

  @retval Value translated from String.

**/

UINTN

EFIAPI

StrDecimalToUintn (

  IN      CONST CHAR16              *String

  )

{

  UINTN     Result;

  StrDecimalToUintnS (String, (CHAR16 **) NULL, &Result);

  return Result;

}

/**

  Convert a Null-terminated Unicode decimal string to a value of

  type UINT64.

  This function returns a value of type UINT64 by interpreting the contents

  of the Unicode string specified by String as a decimal number. The format

  of the input Unicode string String is:

                  [spaces] [decimal digits].

  The valid decimal digit character is in the range [0-9]. The

  function will ignore the pad space, which includes spaces or

  tab characters, before [decimal digits]. The running zero in the

  beginning of [decimal digits] will be ignored. Then, the function

  stops at the first character that is a not a valid decimal character

  or a Null-terminator, whichever one comes first.

  If String is NULL, then ASSERT().

  If String is not aligned in a 16-bit boundary, then ASSERT().

  If String has only pad spaces, then 0 is returned.

  If String has no pad spaces or valid decimal digits,

  then 0 is returned.

  If the number represented by String overflows according

  to the range defined by UINT64, then MAX_UINT64 is returned.

  If PcdMaximumUnicodeStringLength is not zero, and String contains

  more than PcdMaximumUnicodeStringLength Unicode characters, not including

  the Null-terminator, then ASSERT().

  @param  String          A pointer to a Null-terminated Unicode string.

  @retval Value translated from String.

**/

UINT64

EFIAPI

StrDecimalToUint64 (

  IN      CONST CHAR16              *String

  )

{

  UINT64     Result;

  StrDecimalToUint64S (String, (CHAR16 **) NULL, &Result);

  return Result;

}

/**

  Convert a Null-terminated Unicode hexadecimal string to a value of type UINTN.

  This function returns a value of type UINTN by interpreting the contents

  of the Unicode string specified by String as a hexadecimal number.

  The format of the input Unicode string String is:

                  [spaces][zeros][x][hexadecimal digits].

  The valid hexadecimal digit character is in the range [0-9], [a-f] and [A-F].

  The prefix "0x" is optional. Both "x" and "X" is allowed in "0x" prefix.

  If "x" appears in the input string, it must be prefixed with at least one 0.

  The function will ignore the pad space, which includes spaces or tab characters,

  before [zeros], [x] or [hexadecimal digit]. The running zero before [x] or

  [hexadecimal digit] will be ignored. Then, the decoding starts after [x] or the

  first valid hexadecimal digit. Then, the function stops at the first character that is

  a not a valid hexadecimal character or NULL, whichever one comes first.

  If String is NULL, then ASSERT().

  If String is not aligned in a 16-bit boundary, then ASSERT().

  If String has only pad spaces, then zero is returned.

  If String has no leading pad spaces, leading zeros or valid hexadecimal digits,

  then zero is returned.

  If the number represented by String overflows according to the range defined by

  UINTN, then MAX_UINTN is returned.

  If PcdMaximumUnicodeStringLength is not zero, and String contains more than

  PcdMaximumUnicodeStringLength Unicode characters, not including the Null-terminator,

  then ASSERT().

  @param  String          A pointer to a Null-terminated Unicode string.

  @retval Value translated from String.

**/

UINTN

EFIAPI

StrHexToUintn (

  IN      CONST CHAR16              *String

  )

{

  UINTN     Result;

  StrHexToUintnS (String, (CHAR16 **) NULL, &Result);

  return Result;

}

/**

  Convert a Null-terminated Unicode hexadecimal string to a value of type UINT64.

  This function returns a value of type UINT64 by interpreting the contents

  of the Unicode string specified by String as a hexadecimal number.

  The format of the input Unicode string String is

                  [spaces][zeros][x][hexadecimal digits].

  The valid hexadecimal digit character is in the range [0-9], [a-f] and [A-F].

  The prefix "0x" is optional. Both "x" and "X" is allowed in "0x" prefix.

  If "x" appears in the input string, it must be prefixed with at least one 0.

  The function will ignore the pad space, which includes spaces or tab characters,

  before [zeros], [x] or [hexadecimal digit]. The running zero before [x] or

  [hexadecimal digit] will be ignored. Then, the decoding starts after [x] or the

  first valid hexadecimal digit. Then, the function stops at the first character that is

  a not a valid hexadecimal character or NULL, whichever one comes first.

  If String is NULL, then ASSERT().

  If String is not aligned in a 16-bit boundary, then ASSERT().

  If String has only pad spaces, then zero is returned.

  If String has no leading pad spaces, leading zeros or valid hexadecimal digits,

  then zero is returned.

  If the number represented by String overflows according to the range defined by

  UINT64, then MAX_UINT64 is returned.

  If PcdMaximumUnicodeStringLength is not zero, and String contains more than

  PcdMaximumUnicodeStringLength Unicode characters, not including the Null-terminator,

  then ASSERT().

  @param  String          A pointer to a Null-terminated Unicode string.

  @retval Value translated from String.

**/

UINT64

EFIAPI

StrHexToUint64 (

  IN      CONST CHAR16             *String

  )

{

  UINT64    Result;

  StrHexToUint64S (String, (CHAR16 **) NULL, &Result);

  return Result;

}

/**

  Check if a ASCII character is a decimal character.

  This internal function checks if a Unicode character is a

  decimal character. The valid decimal character is from

  '0' to '9'.

  @param  Char  The character to check against.

  @retval TRUE  If the Char is a decmial character.

  @retval FALSE If the Char is not a decmial character.

**/

BOOLEAN

EFIAPI

InternalAsciiIsDecimalDigitCharacter (

  IN      CHAR8                     Char

  )

{

  return (BOOLEAN) (Char >= '0' && Char <= '9');

}

/**

  Check if a ASCII character is a hexadecimal character.

  This internal function checks if a ASCII character is a

  decimal character.  The valid hexadecimal character is

  L'0' to L'9', L'a' to L'f', or L'A' to L'F'.

  @param  Char  The character to check against.

  @retval TRUE  If the Char is a hexadecmial character.

  @retval FALSE If the Char is not a hexadecmial character.

**/

BOOLEAN

EFIAPI

InternalAsciiIsHexaDecimalDigitCharacter (

  IN      CHAR8                    Char

  )

{

  return (BOOLEAN) (InternalAsciiIsDecimalDigitCharacter (Char) ||

    (Char >= 'A' && Char <= 'F') ||

    (Char >= 'a' && Char <= 'f'));

}

/**

  Returns the length of a Null-terminated ASCII string.

  This function returns the number of ASCII characters in the Null-terminated

  ASCII string specified by String.

  If Length > 0 and Destination is NULL, then ASSERT().

  If Length > 0 and Source is NULL, then ASSERT().

  If PcdMaximumAsciiStringLength is not zero and String contains more than

  PcdMaximumAsciiStringLength ASCII characters, not including the Null-terminator,

  then ASSERT().

  @param  String  A pointer to a Null-terminated ASCII string.

  @return The length of String.

**/

UINTN

EFIAPI

AsciiStrLen (

  IN      CONST CHAR8               *String

  )

{

  UINTN                             Length;

  ASSERT (String != NULL);

  for (Length = 0; *String != '\0'; String++, Length++) {

    //

    // If PcdMaximumUnicodeStringLength is not zero,

    // length should not more than PcdMaximumUnicodeStringLength

    //

  }

  return Length;

}

/**

  Returns the size of a Null-terminated ASCII string in bytes, including the

  Null terminator.

  This function returns the size, in bytes, of the Null-terminated ASCII string

  specified by String.

  If String is NULL, then ASSERT().

  If PcdMaximumAsciiStringLength is not zero and String contains more than

  PcdMaximumAsciiStringLength ASCII characters, not including the Null-terminator,

  then ASSERT().

  @param  String  A pointer to a Null-terminated ASCII string.

  @return The size of String.

**/

UINTN

EFIAPI

AsciiStrSize (

  IN      CONST CHAR8               *String

  )

{

  return (AsciiStrLen (String) + 1) * sizeof (*String);

}

/**

  Compares two Null-terminated ASCII strings, and returns the difference

  between the first mismatched ASCII characters.

  This function compares the Null-terminated ASCII string FirstString to the

  Null-terminated ASCII string SecondString. If FirstString is identical to

  SecondString, then 0 is returned. Otherwise, the value returned is the first

  mismatched ASCII character in SecondString subtracted from the first

  mismatched ASCII character in FirstString.

  If FirstString is NULL, then ASSERT().

  If SecondString is NULL, then ASSERT().

  If PcdMaximumAsciiStringLength is not zero and FirstString contains more than

  PcdMaximumAsciiStringLength ASCII characters, not including the Null-terminator,

  then ASSERT().

  If PcdMaximumAsciiStringLength is not zero and SecondString contains more

  than PcdMaximumAsciiStringLength ASCII characters, not including the

  Null-terminator, then ASSERT().

  @param  FirstString   A pointer to a Null-terminated ASCII string.

  @param  SecondString  A pointer to a Null-terminated ASCII string.

  @retval ==0      FirstString is identical to SecondString.

  @retval !=0      FirstString is not identical to SecondString.

**/

INTN

EFIAPI

AsciiStrCmp (

  IN      CONST CHAR8               *FirstString,

  IN      CONST CHAR8               *SecondString

  )

{

  //

  // ASSERT both strings are less long than PcdMaximumAsciiStringLength

  //

  ASSERT (AsciiStrSize (FirstString));

  ASSERT (AsciiStrSize (SecondString));

  while ((*FirstString != '\0') && (*FirstString == *SecondString)) {

    FirstString++;

    SecondString++;

  }

  return *FirstString - *SecondString;

}

/**

  Converts a lowercase Ascii character to upper one.

  If Chr is lowercase Ascii character, then converts it to upper one.

  If Value >= 0xA0, then ASSERT().

  If (Value & 0x0F) >= 0x0A, then ASSERT().

  @param  Chr   one Ascii character

  @return The uppercase value of Ascii character

**/

CHAR8

EFIAPI

InternalBaseLibAsciiToUpper (

  IN      CHAR8                     Chr

  )

{

  return (UINT8) ((Chr >= 'a' && Chr <= 'z') ? Chr - ('a' - 'A') : Chr);

}

/**

  Convert a ASCII character to numerical value.

  This internal function only deal with Unicode character

  which maps to a valid hexadecimal ASII character, i.e.

  '0' to '9', 'a' to 'f' or 'A' to 'F'. For other

  ASCII character, the value returned does not make sense.

  @param  Char  The character to convert.

  @return The numerical value converted.

**/

UINTN

EFIAPI

InternalAsciiHexCharToUintn (

  IN      CHAR8                    Char

  )

{

  if (InternalIsDecimalDigitCharacter (Char)) {

    return Char - '0';

  }

  return (10 + InternalBaseLibAsciiToUpper (Char) - 'A');

}

/**

  Performs a case insensitive comparison of two Null-terminated ASCII strings,

  and returns the difference between the first mismatched ASCII characters.

  This function performs a case insensitive comparison of the Null-terminated

  ASCII string FirstString to the Null-terminated ASCII string SecondString. If

  FirstString is identical to SecondString, then 0 is returned. Otherwise, the

  value returned is the first mismatched lower case ASCII character in

  SecondString subtracted from the first mismatched lower case ASCII character

  in FirstString.

  If FirstString is NULL, then ASSERT().

  If SecondString is NULL, then ASSERT().

  If PcdMaximumAsciiStringLength is not zero and FirstString contains more than

  PcdMaximumAsciiStringLength ASCII characters, not including the Null-terminator,

  then ASSERT().

  If PcdMaximumAsciiStringLength is not zero and SecondString contains more

  than PcdMaximumAsciiStringLength ASCII characters, not including the

  Null-terminator, then ASSERT().

  @param  FirstString   A pointer to a Null-terminated ASCII string.

  @param  SecondString  A pointer to a Null-terminated ASCII string.

  @retval ==0    FirstString is identical to SecondString using case insensitive

                 comparisons.

  @retval !=0    FirstString is not identical to SecondString using case

                 insensitive comparisons.

**/

INTN

EFIAPI

AsciiStriCmp (

  IN      CONST CHAR8               *FirstString,

  IN      CONST CHAR8               *SecondString

  )

{

  CHAR8  UpperFirstString;

  CHAR8  UpperSecondString;

  //

  // ASSERT both strings are less long than PcdMaximumAsciiStringLength

  //

  ASSERT (AsciiStrSize (FirstString));

  ASSERT (AsciiStrSize (SecondString));

  UpperFirstString  = InternalBaseLibAsciiToUpper (*FirstString);

  UpperSecondString = InternalBaseLibAsciiToUpper (*SecondString);

  while ((*FirstString != '\0') && (*SecondString != '\0') && (UpperFirstString == UpperSecondString)) {

    FirstString++;

    SecondString++;

    UpperFirstString  = InternalBaseLibAsciiToUpper (*FirstString);

    UpperSecondString = InternalBaseLibAsciiToUpper (*SecondString);

  }

  return UpperFirstString - UpperSecondString;

}

/**

  Compares two Null-terminated ASCII strings with maximum lengths, and returns

  the difference between the first mismatched ASCII characters.

  This function compares the Null-terminated ASCII string FirstString to the

  Null-terminated ASCII  string SecondString. At most, Length ASCII characters

  will be compared. If Length is 0, then 0 is returned. If FirstString is

  identical to SecondString, then 0 is returned. Otherwise, the value returned

  is the first mismatched ASCII character in SecondString subtracted from the

  first mismatched ASCII character in FirstString.

  If Length > 0 and FirstString is NULL, then ASSERT().

  If Length > 0 and SecondString is NULL, then ASSERT().

  If PcdMaximumAsciiStringLength is not zero, and Length is greater than

  PcdMaximumAsciiStringLength, then ASSERT().

  If PcdMaximumAsciiStringLength is not zero, and FirstString contains more than

  PcdMaximumAsciiStringLength ASCII characters, not including the Null-terminator,

  then ASSERT().

  If PcdMaximumAsciiStringLength is not zero, and SecondString contains more than

  PcdMaximumAsciiStringLength ASCII characters, not including the Null-terminator,

  then ASSERT().

  @param  FirstString   A pointer to a Null-terminated ASCII string.

  @param  SecondString  A pointer to a Null-terminated ASCII string.

  @param  Length        The maximum number of ASCII characters for compare.

  @retval ==0       FirstString is identical to SecondString.

  @retval !=0       FirstString is not identical to SecondString.

**/

INTN

EFIAPI

AsciiStrnCmp (

  IN      CONST CHAR8               *FirstString,

  IN      CONST CHAR8               *SecondString,

  IN      UINTN                     Length

  )

{

  if (Length == 0) {

    return 0;

  }

  //

  // ASSERT both strings are less long than PcdMaximumAsciiStringLength

  //

  ASSERT (AsciiStrSize (FirstString));

  ASSERT (AsciiStrSize (SecondString));

  while ((*FirstString != '\0') &&

         (*SecondString != '\0') &&

         (*FirstString == *SecondString) &&

         (Length > 1)) {

    FirstString++;

    SecondString++;

    Length--;

  }

  return *FirstString - *SecondString;

}

/**

  Returns the first occurrence of a Null-terminated ASCII sub-string

  in a Null-terminated ASCII string.

  This function scans the contents of the ASCII string specified by String

  and returns the first occurrence of SearchString. If SearchString is not

  found in String, then NULL is returned. If the length of SearchString is zero,

  then String is returned.

  If String is NULL, then ASSERT().

  If SearchString is NULL, then ASSERT().

  If PcdMaximumAsciiStringLength is not zero, and SearchString or

  String contains more than PcdMaximumAsciiStringLength Unicode characters

  not including the Null-terminator, then ASSERT().

  @param  String          A pointer to a Null-terminated ASCII string.

  @param  SearchString    A pointer to a Null-terminated ASCII string to search for.

  @retval NULL            If the SearchString does not appear in String.

  @retval others          If there is a match return the first occurrence of SearchingString.

                          If the length of SearchString is zero,return String.

**/

CHAR8 *

EFIAPI

AsciiStrStr (

  IN      CONST CHAR8               *String,

  IN      CONST CHAR8               *SearchString

  )

{

  CONST CHAR8 *FirstMatch;

  CONST CHAR8 *SearchStringTmp;

  //

  // ASSERT both strings are less long than PcdMaximumAsciiStringLength

  //

  ASSERT (AsciiStrSize (String) != 0);

  ASSERT (AsciiStrSize (SearchString) != 0);

  if (*SearchString == '\0') {

    return (CHAR8 *) String;

  }

  while (*String != '\0') {

    SearchStringTmp = SearchString;

    FirstMatch = String;

    while ((*String == *SearchStringTmp)

            && (*String != '\0')) {

      String++;

      SearchStringTmp++;

    }

    if (*SearchStringTmp == '\0') {

      return (CHAR8 *) FirstMatch;

    }

    if (*String == '\0') {

      return NULL;

    }

    String = FirstMatch + 1;

  }

  return NULL;

}

/**

  Convert a Null-terminated ASCII decimal string to a value of type

  UINTN.

  This function returns a value of type UINTN by interpreting the contents

  of the ASCII string String as a decimal number. The format of the input

  ASCII string String is:

                    [spaces] [decimal digits].

  The valid decimal digit character is in the range [0-9]. The function will

  ignore the pad space, which includes spaces or tab characters, before the digits.

  The running zero in the beginning of [decimal digits] will be ignored. Then, the

  function stops at the first character that is a not a valid decimal character or

  Null-terminator, whichever on comes first.

  If String has only pad spaces, then 0 is returned.

  If String has no pad spaces or valid decimal digits, then 0 is returned.

  If the number represented by String overflows according to the range defined by

  UINTN, then MAX_UINTN is returned.

  If String is NULL, then ASSERT().

  If PcdMaximumAsciiStringLength is not zero, and String contains more than

  PcdMaximumAsciiStringLength ASCII characters not including the Null-terminator,

  then ASSERT().

  @param  String          A pointer to a Null-terminated ASCII string.

  @retval Value translated from String.

**/

UINTN

EFIAPI

AsciiStrDecimalToUintn (

  IN      CONST CHAR8               *String

  )

{

  UINTN     Result;

  AsciiStrDecimalToUintnS (String, (CHAR8 **) NULL, &Result);

  return Result;

}

/**

  Convert a Null-terminated ASCII decimal string to a value of type

  UINT64.

  This function returns a value of type UINT64 by interpreting the contents

  of the ASCII string String as a decimal number. The format of the input

  ASCII string String is:

                    [spaces] [decimal digits].

  The valid decimal digit character is in the range [0-9]. The function will

  ignore the pad space, which includes spaces or tab characters, before the digits.

  The running zero in the beginning of [decimal digits] will be ignored. Then, the

  function stops at the first character that is a not a valid decimal character or

  Null-terminator, whichever on comes first.

  If String has only pad spaces, then 0 is returned.

  If String has no pad spaces or valid decimal digits, then 0 is returned.

  If the number represented by String overflows according to the range defined by

  UINT64, then MAX_UINT64 is returned.

  If String is NULL, then ASSERT().

  If PcdMaximumAsciiStringLength is not zero, and String contains more than

  PcdMaximumAsciiStringLength ASCII characters not including the Null-terminator,

  then ASSERT().

  @param  String          A pointer to a Null-terminated ASCII string.

  @retval Value translated from String.

**/

UINT64

EFIAPI

AsciiStrDecimalToUint64 (

  IN      CONST CHAR8               *String

  )

{

  UINT64     Result;

  AsciiStrDecimalToUint64S (String, (CHAR8 **) NULL, &Result);

  return Result;

}

/**

  Convert a Null-terminated ASCII hexadecimal string to a value of type UINTN.

  This function returns a value of type UINTN by interpreting the contents of

  the ASCII string String as a hexadecimal number. The format of the input ASCII

  string String is:

                  [spaces][zeros][x][hexadecimal digits].

  The valid hexadecimal digit character is in the range [0-9], [a-f] and [A-F].

  The prefix "0x" is optional. Both "x" and "X" is allowed in "0x" prefix. If "x"

  appears in the input string, it must be prefixed with at least one 0. The function

  will ignore the pad space, which includes spaces or tab characters, before [zeros],

  [x] or [hexadecimal digits]. The running zero before [x] or [hexadecimal digits]

  will be ignored. Then, the decoding starts after [x] or the first valid hexadecimal

  digit. Then, the function stops at the first character that is a not a valid

  hexadecimal character or Null-terminator, whichever on comes first.

  If String has only pad spaces, then 0 is returned.

  If String has no leading pad spaces, leading zeros or valid hexadecimal digits, then

  0 is returned.

  If the number represented by String overflows according to the range defined by UINTN,

  then MAX_UINTN is returned.

  If String is NULL, then ASSERT().

  If PcdMaximumAsciiStringLength is not zero,

  and String contains more than PcdMaximumAsciiStringLength ASCII characters not including

  the Null-terminator, then ASSERT().

  @param  String          A pointer to a Null-terminated ASCII string.

  @retval Value translated from String.

**/

UINTN

EFIAPI

AsciiStrHexToUintn (