/** @file
  AML String.

  Copyright (c) 2010 - 2018, Intel Corporation. All rights reserved. <BR>
  Copyright (c) 2019 - 2020, Arm Limited. All rights reserved.<BR>

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

#include <String/AmlString.h>

#include <AmlDefines.h>
#include <IndustryStandard/AcpiAml.h>

/** Check NameString/path information is valid.

  Root, ParentPrefix and SegCount cannot be 0 at the same time.
  This function works for ASL and AML name strings.

  @param [in]   Root          Number of root char.
                              Must be 0 or 1.
  @param [in]   ParentPrefix  Number of carets char ('^').
                              Must be [0-255].
  @param [in]   SegCount      Number of NameSeg (s).
                              Must be [0-255].

  @retval TRUE id the input information is in the right boundaries.
          FALSE otherwise.
**/
BOOLEAN
EFIAPI
AmlIsNameString (
  IN  UINT32    Root,
  IN  UINT32    ParentPrefix,
  IN  UINT32    SegCount
  )
{
  if (((Root == 0) || (Root == 1))            &&
      (ParentPrefix <= MAX_UINT8)             &&
      (!((ParentPrefix != 0) && (Root != 0))) &&
      (SegCount <= MAX_UINT8)                 &&
      ((SegCount + Root + ParentPrefix) != 0)) {
    return TRUE;
  }
  return FALSE;
}

/** Copy bytes from SrcBuffer to DstBuffer and convert to upper case.
    Don't copy more than MaxDstBufferSize bytes.

  @param  [out] DstBuffer         Destination buffer.
  @param  [in]  MaxDstBufferSize  Maximum size of DstBuffer.
                                  Must be non-zero.
  @param  [in]  SrcBuffer         Source buffer.
  @param  [in]  Count             Count of bytes to copy from SrcBuffer.
                                  Return success if 0.

  @retval EFI_SUCCESS             The function completed successfully.
  @retval EFI_INVALID_PARAMETER   Invalid parameter.
**/
EFI_STATUS
EFIAPI
AmlUpperCaseMemCpyS (
  OUT       CHAR8   * DstBuffer,
  IN        UINT32    MaxDstBufferSize,
  IN  CONST CHAR8   * SrcBuffer,
  IN        UINT32    Count
  )
{
  UINT32 Index;

  if ((DstBuffer == NULL) ||
      (SrcBuffer == NULL)) {
    ASSERT (0);
    return EFI_INVALID_PARAMETER;
  }

  if (Count == 0) {
    return EFI_SUCCESS;
  }

  if (Count > MaxDstBufferSize) {
    Count = MaxDstBufferSize;
  }

  for (Index = 0; Index < Count; Index++) {
    if ((SrcBuffer[Index] >= 'a') && (SrcBuffer[Index] <= 'z')) {
      DstBuffer[Index] = (CHAR8)((UINT8)SrcBuffer[Index] - ('a' - 'A'));
    } else {
      DstBuffer[Index] = SrcBuffer[Index];
    }
  }

  return EFI_SUCCESS;
}

/** Check whether Buffer is a root path ('\').

  This function works for both ASL and AML pathnames.
  Buffer must be at least 2 bytes long.

  @param  [in]  Buffer   An ASL/AML path.

  @retval TRUE    Buffer is a root path
  @retval FALSE   Buffer is not a root path.
**/
BOOLEAN
EFIAPI
AmlIsRootPath (
  IN  CONST  CHAR8  * Buffer
  )
{
  if (Buffer == NULL) {
    return FALSE;
  }

  if ((Buffer[0] == AML_ROOT_CHAR) && (Buffer[1] == '\0')) {
    return TRUE;
  } else {
    return FALSE;
  }
}

/** Check whether Ch is an ASL/AML LeadName.

  This function works for both ASL and AML pathnames.

  ACPI 6.3 specification, s19.2.2. "ASL Name and Pathname Terms":
  LeadNameChar := 'A'-'Z' | 'a'-'z' | '_'

  ACPI 6.3 specification, s20.2.2. "Name Objects Encoding":
  LeadNameChar := 'A'-'Z' | 'a'-'z' | '_'

  @param  [in]  Ch    The char to test.

  @retval TRUE    Ch is an ASL/AML LeadName.
  @retval FALSE   Ch is not an ASL/AML LeadName.
**/
BOOLEAN
EFIAPI
AmlIsLeadNameChar (
  IN  CHAR8   Ch
  )
{
  if ((Ch == '_') || (Ch >= 'A' && Ch <= 'Z') || (Ch >= 'a' && Ch <= 'z')) {
    return TRUE;
  } else {
    return FALSE;
  }
}

/** Check whether Ch is an ASL/AML NameChar.

  This function works for both ASL and AML pathnames.

  ACPI 6.3 specification, s19.2.2. "ASL Name and Pathname Terms":
  NameChar := DigitChar | LeadNameChar
  LeadNameChar := 'A'-'Z' | 'a'-'z' | '_'
  DigitChar := '0'-'9'

  ACPI 6.3 specification, s20.2.2. "Name Objects Encoding":
  NameChar := DigitChar | LeadNameChar
  LeadNameChar := 'A'-'Z' | 'a'-'z' | '_'
  DigitChar := '0'-'9'

  @param  [in]  Ch    The char to test.

  @retval TRUE    Ch is an ASL/AML NameChar.
  @retval FALSE   Ch is not an ASL/AML NameChar.
**/
BOOLEAN
EFIAPI
AmlIsNameChar (
  IN  CHAR8  Ch
  )
{
  if (AmlIsLeadNameChar (Ch) || (Ch >= '0' && Ch <= '9')) {
    return TRUE;
  } else {
    return FALSE;
  }
}

/** Check whether AslBuffer is an ASL NameSeg.

  This function only works for ASL NameStrings/pathnames.
  ASL NameStrings/pathnames are at most 4 chars long.

  @param [in]   AslBuffer   Pointer in an ASL NameString/pathname.
  @param [out]  Size        Size of the NameSeg.

  @retval TRUE    AslBuffer is an ASL NameSeg.
  @retval FALSE   AslBuffer is not an ASL NameSeg.
**/
BOOLEAN
EFIAPI
AslIsNameSeg (
  IN  CONST  CHAR8    * AslBuffer,
  OUT        UINT32   * Size
  )
{
  UINT32    Index;

  if ((AslBuffer == NULL) ||
      (Size == NULL)) {
    return FALSE;
  }

  if (!AmlIsLeadNameChar (AslBuffer[0])) {
    return FALSE;
  }

  for (Index = 1; Index < AML_NAME_SEG_SIZE; Index++) {
    if ((AslBuffer[Index] == '.')   ||
        (AslBuffer[Index] == '\0')) {
      *Size = Index;
      return TRUE;
    } else if (!AmlIsNameChar (AslBuffer[Index])) {
      return FALSE;
    }
  }

  *Size = Index;
  return TRUE;
}

/** Check whether AmlBuffer is an AML NameSeg.

  This function only works for AML NameStrings/pathnames.
  AML NameStrings/pathnames must be 4 chars long.

  @param [in] AmlBuffer   Pointer in an AML NameString/pathname.

  @retval TRUE    AmlBuffer is an AML NameSeg.
  @retval FALSE   AmlBuffer is not an AML NameSeg.
**/
BOOLEAN
EFIAPI
AmlIsNameSeg (
  IN  CONST  CHAR8    * AmlBuffer
  )
{
  UINT32    Index;

  if (AmlBuffer == NULL) {
    return FALSE;
  }

  if (!AmlIsLeadNameChar (AmlBuffer[0])) {
    return FALSE;
  }

  for (Index = 1; Index < AML_NAME_SEG_SIZE; Index++) {
    if (!AmlIsNameChar (AmlBuffer[Index])) {
      return FALSE;
    }
  }

  return TRUE;
}

/** Parse an ASL NameString/path.

  An ASL NameString/path must be NULL terminated.
  Information found in the ASL NameString/path is returned via pointers:
  Root, ParentPrefix, SegCount.

  @param [in]    Buffer       ASL NameString/path.
  @param [out]   Root         Pointer holding the number of root char.
                              Can be 0 or 1.
  @param [out]   ParentPrefix Pointer holding the number of carets char ('^').
                              Can be [0-255].
  @param [out]   SegCount     Pointer holding the number of NameSeg (s).
                              Can be [0-255].

  @retval EFI_SUCCESS             The function completed successfully.
  @retval EFI_INVALID_PARAMETER   Invalid parameter.
**/
EFI_STATUS
EFIAPI
AslParseNameStringInfo (
  IN  CONST CHAR8     * Buffer,
  OUT       UINT32    * Root,
  OUT       UINT32    * ParentPrefix,
  OUT       UINT32    * SegCount
  )
{
  UINT32      NameSegSize;

  if ((Buffer == NULL)        ||
      (Root == NULL)          ||
      (ParentPrefix == NULL)  ||
      (SegCount == NULL)) {
    ASSERT (0);
    return EFI_INVALID_PARAMETER;
  }

  *Root = 0;
  *ParentPrefix = 0;
  *SegCount = 0;

  // Handle Root and ParentPrefix(s).
  if (*Buffer == AML_ROOT_CHAR) {
    *Root = 1;
    Buffer++;
  } else if (*Buffer == AML_PARENT_PREFIX_CHAR) {
    do {
      Buffer++;
      (*ParentPrefix)++;
    } while (*Buffer == AML_PARENT_PREFIX_CHAR);
  }

  // Handle SegCount(s).
  while (AslIsNameSeg (Buffer, &NameSegSize)) {
    // Safety checks on NameSegSize.
    if ((NameSegSize == 0) || (NameSegSize > AML_NAME_SEG_SIZE)) {
      ASSERT (0);
      return EFI_INVALID_PARAMETER;
    }

    // Increment the NameSeg count.
    (*SegCount)++;
    Buffer += NameSegSize;

    // Skip the '.' separator if present.
    if (*Buffer == '.') {
      Buffer++;
    }
  } // while

  // An ASL NameString/path must be NULL terminated.
  if (*Buffer != '\0') {
    ASSERT (0);
    return EFI_INVALID_PARAMETER;
  }

  if (!AmlIsNameString (*Root, *ParentPrefix, *SegCount)) {
    ASSERT (0);
    return EFI_INVALID_PARAMETER;
  }

  return EFI_SUCCESS;
}

/** Parse an AML NameString/path.

  It is possible to determine the size of an AML NameString/path just
  by sight reading it. So no overflow can occur.
  Information found in the AML NameString/path is returned via pointers:
  Root, ParentPrefix, SegCount.

  @param [in]    Buffer         AML NameString/path.
  @param [out]   Root           Pointer holding the number of root char.
                                Can be 0 or 1.
  @param [out]   ParentPrefix   Pointer holding the number of carets char ('^').
                                Can be [0-255].
  @param [out]   SegCount       Pointer holding the number of NameSeg(s).
                                Can be [0-255].

  @retval EFI_SUCCESS             The function completed successfully.
  @retval EFI_INVALID_PARAMETER   Invalid parameter.
**/
EFI_STATUS
EFIAPI
AmlParseNameStringInfo (
  IN  CONST CHAR8   * Buffer,
  OUT       UINT32  * Root,
  OUT       UINT32  * ParentPrefix,
  OUT       UINT32  * SegCount
  )
{
  if ((Buffer == NULL) ||
      (Root == NULL)   ||
      (ParentPrefix == NULL) ||
      (SegCount == NULL)) {
    ASSERT (0);
    return EFI_INVALID_PARAMETER;
  }

  *Root = 0;
  *ParentPrefix = 0;
  *SegCount = 0;

  // Handle Root and ParentPrefix(s).
  if (*Buffer == AML_ROOT_CHAR) {
    *Root = 1;
    Buffer++;
  } else if (*Buffer == AML_PARENT_PREFIX_CHAR) {
    do {
      Buffer++;
      (*ParentPrefix)++;
    } while (*Buffer == AML_PARENT_PREFIX_CHAR);
  }

  // Handle SegCount(s).
  if (*Buffer == AML_DUAL_NAME_PREFIX) {
    *SegCount = 2;
  } else if (*Buffer == AML_MULTI_NAME_PREFIX) {
    *SegCount = *((UINT8*)(Buffer + 1));
  } else if (AmlIsNameSeg (Buffer)) {
    *SegCount = 1;
  } else if (*Buffer == AML_ZERO_OP) {
    *SegCount = 0;
  } else {
    ASSERT (0);
    return EFI_INVALID_PARAMETER;
  }

  // Safety checks on exit.
  if (!AmlIsNameString (*Root, *ParentPrefix, *SegCount)) {
    ASSERT (0);
    return EFI_INVALID_PARAMETER;
  }

  return EFI_SUCCESS;
}

/** Compute the ASL NameString/path size from NameString
    information (Root, ParentPrefix, SegCount).

  @param [in] Root          Number of root char.
                            Can be 0 or 1.
  @param [in] ParentPrefix  Number of carets char ('^').
                            Can be [0-255].
  @param [in] SegCount      Pointer holding the number of NameSeg(s).
                            Can be [0-255].

  @return Size of the ASL NameString/path.
**/
UINT32
EFIAPI
AslComputeNameStringSize (
  IN  UINT32    Root,
  IN  UINT32    ParentPrefix,
  IN  UINT32    SegCount
  )
{
  UINT32    TotalSize;

  if (!AmlIsNameString (Root, ParentPrefix, SegCount)) {
    ASSERT (0);
    return 0;
  }

  // Root and ParentPrefix(s).
  TotalSize = Root + ParentPrefix;

  // Add size required for NameSeg(s).
  TotalSize += (SegCount * AML_NAME_SEG_SIZE);

  // Add size required for '.' separator(s).
  TotalSize += (SegCount > 1) ? (SegCount - 1) : 0;

  // Add 1 byte for NULL termination '\0'.
  TotalSize += 1;

  return TotalSize;
}

/** Compute the AML NameString/path size from NameString
    information (Root, ParentPrefix, SegCount).

  @param [in] Root          Number of root char.
                            Can be 0 or 1.
  @param [in] ParentPrefix  Number of carets char ('^').
                            Can be [0-255].
  @param [in] SegCount      Pointer holding the number of NameSeg(s).
                            Can be [0-255].

  @return Size of the AML NameString/path.
**/
UINT32
EFIAPI
AmlComputeNameStringSize (
  IN  UINT32    Root,
  IN  UINT32    ParentPrefix,
  IN  UINT32    SegCount
  )
{
  UINT32    TotalSize;

  if (!AmlIsNameString (Root, ParentPrefix, SegCount)) {
    ASSERT (0);
    return 0;
  }

  // Root and ParentPrefix(s).
  TotalSize = Root + ParentPrefix;

  // If SegCount == 0, '\0' must end the AML NameString/path.
  TotalSize += (SegCount == 0) ? 1 : (SegCount * AML_NAME_SEG_SIZE);

  // AML prefix. SegCount > 2 = MultiNamePrefix, SegCount = 2 DualNamePrefix.
  TotalSize += (SegCount > 2) ? 2 : ((SegCount == 2) ? 1 : 0);

  return TotalSize;
}

/** Get the ASL NameString/path size.

  @param [in]   AslPath         An ASL NameString/path.
  @param [out]  AslPathSizePtr  Pointer holding the ASL NameString/path size.

  @retval EFI_SUCCESS             Success.
  @retval EFI_INVALID_PARAMETER   Invalid parameter.
**/
EFI_STATUS
EFIAPI
AslGetNameStringSize (
  IN  CONST CHAR8   * AslPath,
  OUT       UINT32  * AslPathSizePtr
  )
{
  if ((AslPath == NULL) ||
      (AslPathSizePtr == NULL)) {
    ASSERT (0);
    return EFI_INVALID_PARAMETER;
  }

  *AslPathSizePtr = 0;
  do {
    (*AslPathSizePtr)++;
    AslPath++;
  } while (*AslPath != '\0');

  return EFI_SUCCESS;
}

/** Get the AML NameString/path size.

  @param [in]   AmlPath         An AML NameString/path.
  @param [out]  AmlPathSizePtr  Pointer holding the AML NameString/path size.

  @retval EFI_SUCCESS             Success.
  @retval EFI_INVALID_PARAMETER   Invalid parameter.
**/
EFI_STATUS
EFIAPI
AmlGetNameStringSize (
  IN   CONST  CHAR8   * AmlPath,
  OUT         UINT32  * AmlPathSizePtr
  )
{
  EFI_STATUS    Status;

  UINT32        Root;
  UINT32        ParentPrefix;
  UINT32        SegCount;

  if ((AmlPath == NULL) ||
      (AmlPathSizePtr == NULL)) {
    ASSERT (0);
    return EFI_INVALID_PARAMETER;
  }

  Status = AmlParseNameStringInfo (
             AmlPath,
             &Root,
             &ParentPrefix,
             &SegCount
             );
  if (EFI_ERROR (Status)) {
    ASSERT (0);
    return Status;
  }

  *AmlPathSizePtr = AmlComputeNameStringSize (Root, ParentPrefix, SegCount);
  if (*AmlPathSizePtr == 0) {
    ASSERT (0);
    return EFI_INVALID_PARAMETER;
  }

  return Status;
}

/** Convert an ASL NameString/path to an AML NameString/path.
    The caller must free the memory allocated in this function
    for AmlPath using FreePool ().

  @param  [in]  AslPath     An ASL NameString/path.
  @param  [out] OutAmlPath  Buffer containing the AML path.

  @retval EFI_SUCCESS             Success.
  @retval EFI_INVALID_PARAMETER   Invalid parameter.
  @retval EFI_OUT_OF_RESOURCES    Failed to allocate memory.
**/
EFI_STATUS
EFIAPI
ConvertAslNameToAmlName (
  IN  CONST  CHAR8   * AslPath,
  OUT        CHAR8  ** OutAmlPath
  )
{
  EFI_STATUS      Status;

  UINT32          Root;
  UINT32          ParentPrefix;
  UINT32          SegCount;
  UINT32          TotalSize;
  UINT32          NameSegSize;

  CONST CHAR8   * AslBuffer;
  CHAR8         * AmlBuffer;
  CHAR8         * AmlPath;

  if ((AslPath == NULL) ||
      (OutAmlPath == NULL)) {
    return EFI_INVALID_PARAMETER;
  }

  // Analyze AslPath. AslPath is checked in the call.
  Status = AslParseNameStringInfo (AslPath, &Root, &ParentPrefix, &SegCount);
  if (EFI_ERROR (Status)) {
    ASSERT (0);
    return Status;
  }

  // Compute TotalSize.
  TotalSize = AmlComputeNameStringSize (Root, ParentPrefix, SegCount);
  if (TotalSize == 0) {
    ASSERT (0);
    return EFI_INVALID_PARAMETER;
  }

  // Allocate memory.
  AmlPath = AllocateZeroPool (TotalSize);
  if (AmlPath == NULL) {
    ASSERT (0);
    return EFI_OUT_OF_RESOURCES;
  }

  AmlBuffer = AmlPath;
  AslBuffer = AslPath;

  // Handle Root and ParentPrefix(s).
  if (Root == 1) {
    *AmlBuffer = AML_ROOT_CHAR;
    AmlBuffer++;
    AslBuffer++;
  } else if (ParentPrefix > 0) {
    SetMem (AmlBuffer, ParentPrefix, AML_PARENT_PREFIX_CHAR);
    AmlBuffer += ParentPrefix;
    AslBuffer += ParentPrefix;
  }

  // Handle prefix and SegCount(s).
  if (SegCount > 2) {
    *AmlBuffer = AML_MULTI_NAME_PREFIX;
    AmlBuffer++;
    *AmlBuffer = (UINT8)SegCount;
    AmlBuffer++;
  } else if (SegCount == 2) {
    *AmlBuffer = AML_DUAL_NAME_PREFIX;
    AmlBuffer++;
  }

  if (SegCount != 0) {
    // Write NameSeg(s).
    while (1) {
      SegCount--;

      // Get the NameSeg size.
      if (!AslIsNameSeg (AslBuffer, &NameSegSize)) {
        ASSERT (0);
        Status = EFI_INVALID_PARAMETER;
        goto error_handler;
      }

      // Convert to Upper case and copy.
      Status = AmlUpperCaseMemCpyS (
                 AmlBuffer,
                 TotalSize,
                 AslBuffer,
                 NameSegSize
                 );
      if (EFI_ERROR (Status)) {
        ASSERT (0);
        goto error_handler;
      }

      // Complete the NameSeg with an underscore ('_') if shorter than 4 bytes.
      SetMem (
        AmlBuffer + NameSegSize,
        AML_NAME_SEG_SIZE - NameSegSize,
        AML_NAME_CHAR__
        );

      // Go to the next NameSeg.
      AmlBuffer += AML_NAME_SEG_SIZE;
      AslBuffer += NameSegSize;

      // Skip the '.' separator.
      if (SegCount != 0) {
        if (*AslBuffer == '.') {
          AslBuffer++;
        } else {
          ASSERT (0);
          Status = EFI_INVALID_PARAMETER;
          goto error_handler;
        }
      } else {
        // (SegCount == 0)
        if (*AslBuffer == '\0') {
          break;
        } else {
          ASSERT (0);
          Status = EFI_INVALID_PARAMETER;
          goto error_handler;
        }
      }
    } // while

  } else {
    // (SegCount == 0)
    // '\0' needs to end the AML NameString/path.
    *AmlBuffer = AML_ZERO_OP;
    AmlBuffer++;
  }

  // Safety checks on exit.
  // Check that AmlPath has been filled with TotalSize bytes.
  if ((SegCount != 0)               ||
      (*AslBuffer != AML_ZERO_OP)   ||
      (((UINT32)(AmlBuffer - AmlPath)) != TotalSize)) {
      ASSERT (0);
      Status = EFI_INVALID_PARAMETER;
      goto error_handler;
  }

  *OutAmlPath = AmlPath;
  return EFI_SUCCESS;

error_handler:
  FreePool (AmlPath);
  return Status;
}

/** Convert an AML NameString/path to an ASL NameString/path.
    The caller must free the memory allocated in this function.
    using FreePool ().

  @param  [in]  AmlPath     An AML NameString/path.
  @param  [out] OutAslPath  Buffer containing the ASL path.

  @retval EFI_SUCCESS             Success.
  @retval EFI_INVALID_PARAMETER   Invalid parameter.
  @retval EFI_OUT_OF_RESOURCES    Failed to allocate memory.
**/
EFI_STATUS
EFIAPI
ConvertAmlNameToAslName (
  IN  CONST CHAR8     * AmlPath,
  OUT       CHAR8    ** OutAslPath
  )
{
  EFI_STATUS      Status;

  UINT32          Root;
  UINT32          ParentPrefix;
  UINT32          SegCount;
  UINT32          TotalSize;

  CONST CHAR8   * AmlBuffer;
  CHAR8         * AslBuffer;
  CHAR8         * AslPath;

  if ((AmlPath == NULL)   ||
      (OutAslPath == NULL)) {
    ASSERT (0);
    return EFI_INVALID_PARAMETER;
  }

  // Analyze AslPath. AmlPath is checked in the call.
  Status = AmlParseNameStringInfo (AmlPath, &Root, &ParentPrefix, &SegCount);
  if (EFI_ERROR (Status)) {
    ASSERT (0);
    return Status;
  }

  // Compute TotalSize.
  TotalSize = AslComputeNameStringSize (Root, ParentPrefix, SegCount);
  if (TotalSize == 0) {
    ASSERT (0);
    return EFI_INVALID_PARAMETER;
  }

  // Allocate memory.
  AslPath = AllocateZeroPool (TotalSize);
  if (AslPath == NULL) {
    ASSERT (0);
    return EFI_OUT_OF_RESOURCES;
  }

  AmlBuffer = AmlPath;
  AslBuffer = AslPath;

  // Handle prefix and SegCount(s).
  if (Root == 1) {
    *AslBuffer = AML_ROOT_CHAR;
    AslBuffer++;
    AmlBuffer++;
  } else if (ParentPrefix > 0) {
    SetMem (AslBuffer, ParentPrefix, AML_PARENT_PREFIX_CHAR);
    AslBuffer += ParentPrefix;
    AmlBuffer += ParentPrefix;
  }

  // Handle Root and Parent(s).
  // Skip the MultiName or DualName prefix chars.
  if (SegCount > 2) {
    AmlBuffer += 2;
  } else if (SegCount == 2) {
    AmlBuffer += 1;
  }

  // Write NameSeg(s).
  while (SegCount) {
    // NameSeg is already in upper case and always 4 bytes long.
    CopyMem (AslBuffer, AmlBuffer, AML_NAME_SEG_SIZE);
    AslBuffer += AML_NAME_SEG_SIZE;
    AmlBuffer += AML_NAME_SEG_SIZE;

    SegCount--;

    // Write the '.' separator if there is another NameSeg following.
    if (SegCount != 0) {
      *AslBuffer = '.';
      AslBuffer++;
    }
  } // while

  // NULL terminate the ASL NameString.
  *AslBuffer = '\0';
  AslBuffer++;

  // Safety checks on exit.
  // Check that AslPath has been filled with TotalSize bytes.
  if (((UINT32)(AslBuffer - AslPath)) != TotalSize) {
    ASSERT (0);
    Status = EFI_INVALID_PARAMETER;
    goto error_handler;
  }

  *OutAslPath = AslPath;
  return EFI_SUCCESS;

error_handler:
  FreePool (AslPath);
  return Status;
}

/** Compare two ASL NameStrings.

  @param [in] AslName1    First NameString to compare.
  @param [in] AslName2    Second NameString to compare.

  @retval TRUE if the two strings are identical.
  @retval FALSE otherwise, or if error.
**/
BOOLEAN
EFIAPI
AslCompareNameString (
  IN  CONST CHAR8 *   AslName1,
  IN  CONST CHAR8 *   AslName2
  )
{
  EFI_STATUS    Status;
  UINT32        AslName1Len;
  UINT32        AslName2Len;

  if ((AslName1 == NULL) ||
      (AslName2 == NULL)) {
    ASSERT (0);
    return FALSE;
  }

  Status = AslGetNameStringSize (AslName1, &AslName1Len);
  if (EFI_ERROR (Status)) {
    ASSERT (0);
    return FALSE;
  }

  Status = AslGetNameStringSize (AslName2, &AslName2Len);
  if (EFI_ERROR (Status)) {
    ASSERT (0);
    return FALSE;
  }

  // AslName1 and AslName2 don't have the same length
  if (AslName1Len != AslName2Len) {
    return FALSE;
  }

  return (CompareMem (AslName1, AslName2, AslName1Len) == 0);
}

/** Compare two AML NameStrings.

  @param [in] AmlName1    First NameString to compare.
  @param [in] AmlName2    Second NameString to compare.

  @retval TRUE if the two strings are identical.
  @retval FALSE otherwise, or if error.
**/
BOOLEAN
EFIAPI
AmlCompareNameString (
  IN  CONST CHAR8 *   AmlName1,
  IN  CONST CHAR8 *   AmlName2
  )
{
  EFI_STATUS    Status;
  UINT32        AmlName1Len;
  UINT32        AmlName2Len;

  if ((AmlName1 == NULL) ||
      (AmlName2 == NULL)) {
    ASSERT (0);
    return FALSE;
  }

  Status = AmlGetNameStringSize (AmlName1, &AmlName1Len);
  if (EFI_ERROR (Status)) {
    ASSERT (0);
    return FALSE;
  }

  Status = AmlGetNameStringSize (AmlName2, &AmlName2Len);
  if (EFI_ERROR (Status)) {
    ASSERT (0);
    return FALSE;
  }

  // AmlName1 and AmlName2 don't have the same length
  if (AmlName1Len != AmlName2Len) {
    return FALSE;
  }

  return (CompareMem (AmlName1, AmlName2, AmlName1Len) == 0);
}

/** Compare an AML NameString and an ASL NameString.

  The ASL NameString is converted to an AML NameString before
  being compared with the ASL NameString. This allows to expand
  NameSegs shorter than 4 chars.
  E.g.: AslName: "DEV" will be expanded to "DEV_" before being
        compared.

  @param [in] AmlName1   AML NameString to compare.
  @param [in] AslName2   ASL NameString to compare.

  @retval TRUE if the two strings are identical.
  @retval FALSE otherwise, or if error.
**/
BOOLEAN
EFIAPI
CompareAmlWithAslNameString (
  IN  CONST CHAR8 *   AmlName1,
  IN  CONST CHAR8 *   AslName2
  )
{
  EFI_STATUS    Status;

  CHAR8       * AmlName2;
  BOOLEAN       RetVal;

  if ((AmlName1 == NULL) ||
      (AslName2 == NULL)) {
    ASSERT (0);
    return FALSE;
  }

  // Convert the AslName2 to an AmlName2.
  // AmlName2 must be freed.
  Status = ConvertAmlNameToAslName (AslName2, &AmlName2);
  if (EFI_ERROR (Status)) {
    ASSERT (0);
    return FALSE;
  }

  RetVal = AmlCompareNameString (AmlName1, AmlName2);

  // Free AmlName2.
  FreePool (AmlName2);

  return RetVal;
}
/** Given an AmlPath, return the address of the first NameSeg.

  It is possible to determine the size of an AML NameString/path just
  by sight reading it. So no overflow can occur.

  @param  [in]  AmlPath       The AML pathname.
  @param  [in]  Root          The AML pathname starts with a root char.
                              It is an absolute path.
  @param  [in]  ParentPrefix  The AML pathname has ParentPrefix
                              carets in its name.

  @return Pointer to the first NameSeg of the NameString.
          Return NULL if AmlPath is NULL.
**/
CONST
CHAR8 *
EFIAPI
AmlGetFirstNameSeg (
  IN  CONST  CHAR8    * AmlPath,
  IN         UINT32     Root,
  IN         UINT32     ParentPrefix
  )
{
  if (AmlPath == NULL) {
    ASSERT (0);
    return NULL;
  }

  AmlPath += Root;
  AmlPath += ParentPrefix;
  AmlPath += ((*AmlPath == AML_MULTI_NAME_PREFIX) ? 2
               : (*AmlPath == AML_DUAL_NAME_PREFIX) ? 1 : 0);
  return AmlPath;
}