Renormalized end-of-lines from master@27b044605cd5f6b33a3d231576003850b3fe305btrunk

1 files changed, 382 insertions, 382 deletions

diff --git a/MdeModulePkg/Universal/RegularExpressionDxe/RegularExpressionDxe.c b/MdeModulePkg/Universal/RegularExpressionDxe/RegularExpressionDxe.c
index 326a6e6884..fff4fa78ca 100644
--- a/MdeModulePkg/Universal/RegularExpressionDxe/RegularExpressionDxe.c
+++ b/MdeModulePkg/Universal/RegularExpressionDxe/RegularExpressionDxe.c
@@ -1,382 +1,382 @@
-/** @file

-

-  EFI_REGULAR_EXPRESSION_PROTOCOL Implementation

-

-  (C) Copyright 2015-2016 Hewlett Packard Enterprise Development LP<BR>

-

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

-

-**/

-

-#include "RegularExpressionDxe.h"

-

-STATIC

-EFI_REGEX_SYNTAX_TYPE *CONST  mSupportedSyntaxes[] = {

-  &gEfiRegexSyntaxTypePosixExtendedGuid,

-  &gEfiRegexSyntaxTypePerlGuid

-};

-

-STATIC

-EFI_REGULAR_EXPRESSION_PROTOCOL  mProtocolInstance = {

-  RegularExpressionMatch,

-  RegularExpressionGetInfo

-};

-

-#define CHAR16_ENCODING  ONIG_ENCODING_UTF16_LE

-

-/**

-  Call the Oniguruma regex match API.

-

-  Same parameters as RegularExpressionMatch, except SyntaxType is required.

-

-  @param String         A pointer to a NULL terminated string to match against the

-                        regular expression string specified by Pattern.

-

-  @param Pattern        A pointer to a NULL terminated string that represents the

-                        regular expression.

-  @param SyntaxType     A pointer to the EFI_REGEX_SYNTAX_TYPE that identifies the

-                        regular expression syntax type to use. May be NULL in which

-                        case the function will use its default regular expression

-                        syntax type.

-

-  @param Result         On return, points to TRUE if String fully matches against

-                        the regular expression Pattern using the regular expression

-                        SyntaxType. Otherwise, points to FALSE.

-

-  @param Captures       A Pointer to an array of EFI_REGEX_CAPTURE objects to receive

-                        the captured groups in the event of a match. The full

-                        sub-string match is put in Captures[0], and the results of N

-                        capturing groups are put in Captures[1:N]. If Captures is

-                        NULL, then this function doesn't allocate the memory for the

-                        array and does not build up the elements. It only returns the

-                        number of matching patterns in CapturesCount. If Captures is

-                        not NULL, this function returns a pointer to an array and

-                        builds up the elements in the array. CapturesCount is also

-                        updated to the number of matching patterns found. It is the

-                        caller's responsibility to free the memory pool in Captures

-                        and in each CapturePtr in the array elements.

-

-  @param CapturesCount  On output, CapturesCount is the number of matching patterns

-                        found in String. Zero means no matching patterns were found

-                        in the string.

-

-  @retval  EFI_SUCCESS       Regex compilation and match completed successfully.

-  @retval  EFI_DEVICE_ERROR  Regex compilation failed.

-

-**/

-STATIC

-EFI_STATUS

-OnigurumaMatch (

-  IN  CHAR16                 *String,

-  IN  CHAR16                 *Pattern,

-  IN  EFI_REGEX_SYNTAX_TYPE  *SyntaxType,

-  OUT BOOLEAN                *Result,

-  OUT EFI_REGEX_CAPTURE      **Captures      OPTIONAL,

-  OUT UINTN                  *CapturesCount

-  )

-{

-  regex_t         *OnigRegex;

-  OnigSyntaxType  *OnigSyntax;

-  OnigRegion      *Region;

-  INT32           OnigResult;

-  OnigErrorInfo   ErrorInfo;

-  OnigUChar       ErrorMessage[ONIG_MAX_ERROR_MESSAGE_LEN];

-  UINT32          Index;

-  OnigUChar       *Start;

-  EFI_STATUS      Status;

-

-  Status = EFI_SUCCESS;

-

-  //

-  // Detemine the internal syntax type

-  //

-  OnigSyntax = ONIG_SYNTAX_DEFAULT;

-  if (CompareGuid (SyntaxType, &gEfiRegexSyntaxTypePosixExtendedGuid)) {

-    OnigSyntax = ONIG_SYNTAX_POSIX_EXTENDED;

-  } else if (CompareGuid (SyntaxType, &gEfiRegexSyntaxTypePerlGuid)) {

-    OnigSyntax = ONIG_SYNTAX_PERL;

-  } else {

-    DEBUG ((DEBUG_ERROR, "Unsupported regex syntax - using default\n"));

-    return EFI_UNSUPPORTED;

-  }

-

-  //

-  // Compile pattern

-  //

-  Start      = (OnigUChar *)Pattern;

-  OnigResult = onig_new (

-                 &OnigRegex,

-                 Start,

-                 Start + onigenc_str_bytelen_null (CHAR16_ENCODING, Start),

-                 ONIG_OPTION_DEFAULT,

-                 CHAR16_ENCODING,

-                 OnigSyntax,

-                 &ErrorInfo

-                 );

-

-  if (OnigResult != ONIG_NORMAL) {

-    onig_error_code_to_str (ErrorMessage, OnigResult, &ErrorInfo);

-    DEBUG ((DEBUG_ERROR, "Regex compilation failed: %a\n", ErrorMessage));

-    return EFI_DEVICE_ERROR;

-  }

-

-  //

-  // Try to match

-  //

-  Start  = (OnigUChar *)String;

-  Region = onig_region_new ();

-  if (Region == NULL) {

-    onig_free (OnigRegex);

-    return EFI_OUT_OF_RESOURCES;

-  }

-

-  OnigResult = onig_search (

-                 OnigRegex,

-                 Start,

-                 Start + onigenc_str_bytelen_null (CHAR16_ENCODING, Start),

-                 Start,

-                 Start + onigenc_str_bytelen_null (CHAR16_ENCODING, Start),

-                 Region,

-                 ONIG_OPTION_NONE

-                 );

-

-  if (OnigResult >= 0) {

-    *Result = TRUE;

-  } else {

-    *Result = FALSE;

-    if (OnigResult != ONIG_MISMATCH) {

-      onig_error_code_to_str (ErrorMessage, OnigResult);

-      DEBUG ((DEBUG_ERROR, "Regex match failed: %a\n", ErrorMessage));

-      onig_region_free (Region, 1);

-      onig_free (OnigRegex);

-      return EFI_DEVICE_ERROR;

-    }

-  }

-

-  //

-  // If successful, copy out the region (capture) information

-  //

-  if (*Result && (Captures != NULL)) {

-    *CapturesCount = Region->num_regs;

-    *Captures      = AllocateZeroPool (*CapturesCount * sizeof (**Captures));

-    if (*Captures != NULL) {

-      for (Index = 0; Index < *CapturesCount; ++Index) {

-        //

-        // Region beg/end values represent bytes, not characters

-        //

-        (*Captures)[Index].Length     = (Region->end[Index] - Region->beg[Index]) / sizeof (CHAR16);

-        (*Captures)[Index].CapturePtr = AllocateCopyPool (

-                                          ((*Captures)[Index].Length) * sizeof (CHAR16),

-                                          (CHAR16 *)((UINTN)String + Region->beg[Index])

-                                          );

-        if ((*Captures)[Index].CapturePtr == NULL) {

-          Status = EFI_OUT_OF_RESOURCES;

-          break;

-        }

-      }

-

-      if (EFI_ERROR (Status)) {

-        for (Index = 0; Index < *CapturesCount; ++Index) {

-          if ((*Captures)[Index].CapturePtr != NULL) {

-            FreePool ((CHAR16 *)(*Captures)[Index].CapturePtr);

-          }

-        }

-

-        FreePool (*Captures);

-      }

-    }

-  }

-

-  onig_region_free (Region, 1);

-  onig_free (OnigRegex);

-

-  return Status;

-}

-

-/**

-  Returns information about the regular expression syntax types supported

-  by the implementation.

-

-  @param This                      A pointer to the EFI_REGULAR_EXPRESSION_PROTOCOL

-                                   instance.

-

-  @param  RegExSyntaxTypeListSize  On input, the size in bytes of RegExSyntaxTypeList.

-                                   On output with a return code of EFI_SUCCESS, the

-                                   size in bytes of the data returned in

-                                   RegExSyntaxTypeList. On output with a return code

-                                   of EFI_BUFFER_TOO_SMALL, the size of

-                                   RegExSyntaxTypeList required to obtain the list.

-

-  @param   RegExSyntaxTypeList     A caller-allocated memory buffer filled by the

-                                   driver with one EFI_REGEX_SYNTAX_TYPE element

-                                   for each supported Regular expression syntax

-                                   type. The list must not change across multiple

-                                   calls to the same driver. The first syntax

-                                   type in the list is the default type for the

-                                   driver.

-

-  @retval EFI_SUCCESS            The regular expression syntax types list

-                                 was returned successfully.

-  @retval EFI_UNSUPPORTED        The service is not supported by this driver.

-  @retval EFI_DEVICE_ERROR       The list of syntax types could not be

-                                 retrieved due to a hardware or firmware error.

-  @retval EFI_BUFFER_TOO_SMALL   The buffer RegExSyntaxTypeList is too small

-                                 to hold the result.

-  @retval EFI_INVALID_PARAMETER  RegExSyntaxTypeListSize is NULL

-

-**/

-EFI_STATUS

-EFIAPI

-RegularExpressionGetInfo (

-  IN     EFI_REGULAR_EXPRESSION_PROTOCOL  *This,

-  IN OUT UINTN                            *RegExSyntaxTypeListSize,

-  OUT    EFI_REGEX_SYNTAX_TYPE            *RegExSyntaxTypeList

-  )

-{

-  UINTN  SyntaxSize;

-  UINTN  Index;

-

-  if ((This == NULL) || (RegExSyntaxTypeListSize == NULL)) {

-    return EFI_INVALID_PARAMETER;

-  }

-

-  if ((*RegExSyntaxTypeListSize != 0) && (RegExSyntaxTypeList == NULL)) {

-    return EFI_INVALID_PARAMETER;

-  }

-

-  SyntaxSize = ARRAY_SIZE (mSupportedSyntaxes) * sizeof (**mSupportedSyntaxes);

-

-  if (*RegExSyntaxTypeListSize < SyntaxSize) {

-    *RegExSyntaxTypeListSize = SyntaxSize;

-    return EFI_BUFFER_TOO_SMALL;

-  }

-

-  for (Index = 0; Index < ARRAY_SIZE (mSupportedSyntaxes); ++Index) {

-    CopyMem (&RegExSyntaxTypeList[Index], mSupportedSyntaxes[Index], sizeof (**mSupportedSyntaxes));

-  }

-

-  *RegExSyntaxTypeListSize = SyntaxSize;

-

-  return EFI_SUCCESS;

-}

-

-/**

-  Checks if the input string matches to the regular expression pattern.

-

-  @param This          A pointer to the EFI_REGULAR_EXPRESSION_PROTOCOL instance.

-                       Type EFI_REGULAR_EXPRESSION_PROTOCOL is defined in Section

-                       XYZ.

-

-  @param String        A pointer to a NULL terminated string to match against the

-                       regular expression string specified by Pattern.

-

-  @param Pattern       A pointer to a NULL terminated string that represents the

-                       regular expression.

-

-  @param SyntaxType    A pointer to the EFI_REGEX_SYNTAX_TYPE that identifies the

-                       regular expression syntax type to use. May be NULL in which

-                       case the function will use its default regular expression

-                       syntax type.

-

-  @param Result        On return, points to TRUE if String fully matches against

-                       the regular expression Pattern using the regular expression

-                       SyntaxType. Otherwise, points to FALSE.

-

-  @param Captures      A Pointer to an array of EFI_REGEX_CAPTURE objects to receive

-                       the captured groups in the event of a match. The full

-                       sub-string match is put in Captures[0], and the results of N

-                       capturing groups are put in Captures[1:N]. If Captures is

-                       NULL, then this function doesn't allocate the memory for the

-                       array and does not build up the elements. It only returns the

-                       number of matching patterns in CapturesCount. If Captures is

-                       not NULL, this function returns a pointer to an array and

-                       builds up the elements in the array. CapturesCount is also

-                       updated to the number of matching patterns found. It is the

-                       caller's responsibility to free the memory pool in Captures

-                       and in each CapturePtr in the array elements.

-

-  @param CapturesCount On output, CapturesCount is the number of matching patterns

-                       found in String. Zero means no matching patterns were found

-                       in the string.

-

-  @retval EFI_SUCCESS            The regular expression string matching

-                                 completed successfully.

-  @retval EFI_UNSUPPORTED        The regular expression syntax specified by

-                                 SyntaxType is not supported by this driver.

-  @retval EFI_DEVICE_ERROR       The regular expression string matching

-                                 failed due to a hardware or firmware error.

-  @retval EFI_INVALID_PARAMETER  String, Pattern, Result, or CapturesCountis

-                                 NULL.

-

-**/

-EFI_STATUS

-EFIAPI

-RegularExpressionMatch (

-  IN  EFI_REGULAR_EXPRESSION_PROTOCOL  *This,

-  IN  CHAR16                           *String,

-  IN  CHAR16                           *Pattern,

-  IN  EFI_REGEX_SYNTAX_TYPE            *SyntaxType  OPTIONAL,

-  OUT BOOLEAN                          *Result,

-  OUT EFI_REGEX_CAPTURE                **Captures  OPTIONAL,

-  OUT UINTN                            *CapturesCount

-  )

-{

-  EFI_STATUS  Status;

-  UINT32      Index;

-  BOOLEAN     Supported;

-

-  if ((This == NULL) || (String == NULL) || (Pattern == NULL) || (Result == NULL) || (CapturesCount == NULL)) {

-    return EFI_INVALID_PARAMETER;

-  }

-

-  //

-  // Figure out which syntax to use

-  //

-  if (SyntaxType == NULL) {

-    SyntaxType = mSupportedSyntaxes[0];

-  } else {

-    Supported = FALSE;

-    for (Index = 0; Index < ARRAY_SIZE (mSupportedSyntaxes); ++Index) {

-      if (CompareGuid (SyntaxType, mSupportedSyntaxes[Index])) {

-        Supported = TRUE;

-        break;

-      }

-    }

-

-    if (!Supported) {

-      return EFI_UNSUPPORTED;

-    }

-  }

-

-  Status = OnigurumaMatch (String, Pattern, SyntaxType, Result, Captures, CapturesCount);

-

-  return Status;

-}

-

-/**

-  Entry point for RegularExpressionDxe.

-

-  @param ImageHandle     Image handle this driver.

-  @param SystemTable     Pointer to SystemTable.

-

-  @retval Status         Whether this function complete successfully.

-

-**/

-EFI_STATUS

-EFIAPI

-RegularExpressionDxeEntry (

-  IN  EFI_HANDLE        ImageHandle,

-  IN  EFI_SYSTEM_TABLE  *SystemTable

-  )

-{

-  EFI_STATUS  Status;

-

-  Status = gBS->InstallMultipleProtocolInterfaces (

-                  &ImageHandle,

-                  &gEfiRegularExpressionProtocolGuid,

-                  &mProtocolInstance,

-                  NULL

-                  );

-

-  return Status;

-}

+/** @file
+
+  EFI_REGULAR_EXPRESSION_PROTOCOL Implementation
+
+  (C) Copyright 2015-2016 Hewlett Packard Enterprise Development LP<BR>
+
+  SPDX-License-Identifier: BSD-2-Clause-Patent
+
+**/
+
+#include "RegularExpressionDxe.h"
+
+STATIC
+EFI_REGEX_SYNTAX_TYPE *CONST  mSupportedSyntaxes[] = {
+  &gEfiRegexSyntaxTypePosixExtendedGuid,
+  &gEfiRegexSyntaxTypePerlGuid
+};
+
+STATIC
+EFI_REGULAR_EXPRESSION_PROTOCOL  mProtocolInstance = {
+  RegularExpressionMatch,
+  RegularExpressionGetInfo
+};
+
+#define CHAR16_ENCODING  ONIG_ENCODING_UTF16_LE
+
+/**
+  Call the Oniguruma regex match API.
+
+  Same parameters as RegularExpressionMatch, except SyntaxType is required.
+
+  @param String         A pointer to a NULL terminated string to match against the
+                        regular expression string specified by Pattern.
+
+  @param Pattern        A pointer to a NULL terminated string that represents the
+                        regular expression.
+  @param SyntaxType     A pointer to the EFI_REGEX_SYNTAX_TYPE that identifies the
+                        regular expression syntax type to use. May be NULL in which
+                        case the function will use its default regular expression
+                        syntax type.
+
+  @param Result         On return, points to TRUE if String fully matches against
+                        the regular expression Pattern using the regular expression
+                        SyntaxType. Otherwise, points to FALSE.
+
+  @param Captures       A Pointer to an array of EFI_REGEX_CAPTURE objects to receive
+                        the captured groups in the event of a match. The full
+                        sub-string match is put in Captures[0], and the results of N
+                        capturing groups are put in Captures[1:N]. If Captures is
+                        NULL, then this function doesn't allocate the memory for the
+                        array and does not build up the elements. It only returns the
+                        number of matching patterns in CapturesCount. If Captures is
+                        not NULL, this function returns a pointer to an array and
+                        builds up the elements in the array. CapturesCount is also
+                        updated to the number of matching patterns found. It is the
+                        caller's responsibility to free the memory pool in Captures
+                        and in each CapturePtr in the array elements.
+
+  @param CapturesCount  On output, CapturesCount is the number of matching patterns
+                        found in String. Zero means no matching patterns were found
+                        in the string.
+
+  @retval  EFI_SUCCESS       Regex compilation and match completed successfully.
+  @retval  EFI_DEVICE_ERROR  Regex compilation failed.
+
+**/
+STATIC
+EFI_STATUS
+OnigurumaMatch (
+  IN  CHAR16                 *String,
+  IN  CHAR16                 *Pattern,
+  IN  EFI_REGEX_SYNTAX_TYPE  *SyntaxType,
+  OUT BOOLEAN                *Result,
+  OUT EFI_REGEX_CAPTURE      **Captures      OPTIONAL,
+  OUT UINTN                  *CapturesCount
+  )
+{
+  regex_t         *OnigRegex;
+  OnigSyntaxType  *OnigSyntax;
+  OnigRegion      *Region;
+  INT32           OnigResult;
+  OnigErrorInfo   ErrorInfo;
+  OnigUChar       ErrorMessage[ONIG_MAX_ERROR_MESSAGE_LEN];
+  UINT32          Index;
+  OnigUChar       *Start;
+  EFI_STATUS      Status;
+
+  Status = EFI_SUCCESS;
+
+  //
+  // Detemine the internal syntax type
+  //
+  OnigSyntax = ONIG_SYNTAX_DEFAULT;
+  if (CompareGuid (SyntaxType, &gEfiRegexSyntaxTypePosixExtendedGuid)) {
+    OnigSyntax = ONIG_SYNTAX_POSIX_EXTENDED;
+  } else if (CompareGuid (SyntaxType, &gEfiRegexSyntaxTypePerlGuid)) {
+    OnigSyntax = ONIG_SYNTAX_PERL;
+  } else {
+    DEBUG ((DEBUG_ERROR, "Unsupported regex syntax - using default\n"));
+    return EFI_UNSUPPORTED;
+  }
+
+  //
+  // Compile pattern
+  //
+  Start      = (OnigUChar *)Pattern;
+  OnigResult = onig_new (
+                 &OnigRegex,
+                 Start,
+                 Start + onigenc_str_bytelen_null (CHAR16_ENCODING, Start),
+                 ONIG_OPTION_DEFAULT,
+                 CHAR16_ENCODING,
+                 OnigSyntax,
+                 &ErrorInfo
+                 );
+
+  if (OnigResult != ONIG_NORMAL) {
+    onig_error_code_to_str (ErrorMessage, OnigResult, &ErrorInfo);
+    DEBUG ((DEBUG_ERROR, "Regex compilation failed: %a\n", ErrorMessage));
+    return EFI_DEVICE_ERROR;
+  }
+
+  //
+  // Try to match
+  //
+  Start  = (OnigUChar *)String;
+  Region = onig_region_new ();
+  if (Region == NULL) {
+    onig_free (OnigRegex);
+    return EFI_OUT_OF_RESOURCES;
+  }
+
+  OnigResult = onig_search (
+                 OnigRegex,
+                 Start,
+                 Start + onigenc_str_bytelen_null (CHAR16_ENCODING, Start),
+                 Start,
+                 Start + onigenc_str_bytelen_null (CHAR16_ENCODING, Start),
+                 Region,
+                 ONIG_OPTION_NONE
+                 );
+
+  if (OnigResult >= 0) {
+    *Result = TRUE;
+  } else {
+    *Result = FALSE;
+    if (OnigResult != ONIG_MISMATCH) {
+      onig_error_code_to_str (ErrorMessage, OnigResult);
+      DEBUG ((DEBUG_ERROR, "Regex match failed: %a\n", ErrorMessage));
+      onig_region_free (Region, 1);
+      onig_free (OnigRegex);
+      return EFI_DEVICE_ERROR;
+    }
+  }
+
+  //
+  // If successful, copy out the region (capture) information
+  //
+  if (*Result && (Captures != NULL)) {
+    *CapturesCount = Region->num_regs;
+    *Captures      = AllocateZeroPool (*CapturesCount * sizeof (**Captures));
+    if (*Captures != NULL) {
+      for (Index = 0; Index < *CapturesCount; ++Index) {
+        //
+        // Region beg/end values represent bytes, not characters
+        //
+        (*Captures)[Index].Length     = (Region->end[Index] - Region->beg[Index]) / sizeof (CHAR16);
+        (*Captures)[Index].CapturePtr = AllocateCopyPool (
+                                          ((*Captures)[Index].Length) * sizeof (CHAR16),
+                                          (CHAR16 *)((UINTN)String + Region->beg[Index])
+                                          );
+        if ((*Captures)[Index].CapturePtr == NULL) {
+          Status = EFI_OUT_OF_RESOURCES;
+          break;
+        }
+      }
+
+      if (EFI_ERROR (Status)) {
+        for (Index = 0; Index < *CapturesCount; ++Index) {
+          if ((*Captures)[Index].CapturePtr != NULL) {
+            FreePool ((CHAR16 *)(*Captures)[Index].CapturePtr);
+          }
+        }
+
+        FreePool (*Captures);
+      }
+    }
+  }
+
+  onig_region_free (Region, 1);
+  onig_free (OnigRegex);
+
+  return Status;
+}
+
+/**
+  Returns information about the regular expression syntax types supported
+  by the implementation.
+
+  @param This                      A pointer to the EFI_REGULAR_EXPRESSION_PROTOCOL
+                                   instance.
+
+  @param  RegExSyntaxTypeListSize  On input, the size in bytes of RegExSyntaxTypeList.
+                                   On output with a return code of EFI_SUCCESS, the
+                                   size in bytes of the data returned in
+                                   RegExSyntaxTypeList. On output with a return code
+                                   of EFI_BUFFER_TOO_SMALL, the size of
+                                   RegExSyntaxTypeList required to obtain the list.
+
+  @param   RegExSyntaxTypeList     A caller-allocated memory buffer filled by the
+                                   driver with one EFI_REGEX_SYNTAX_TYPE element
+                                   for each supported Regular expression syntax
+                                   type. The list must not change across multiple
+                                   calls to the same driver. The first syntax
+                                   type in the list is the default type for the
+                                   driver.
+
+  @retval EFI_SUCCESS            The regular expression syntax types list
+                                 was returned successfully.
+  @retval EFI_UNSUPPORTED        The service is not supported by this driver.
+  @retval EFI_DEVICE_ERROR       The list of syntax types could not be
+                                 retrieved due to a hardware or firmware error.
+  @retval EFI_BUFFER_TOO_SMALL   The buffer RegExSyntaxTypeList is too small
+                                 to hold the result.
+  @retval EFI_INVALID_PARAMETER  RegExSyntaxTypeListSize is NULL
+
+**/
+EFI_STATUS
+EFIAPI
+RegularExpressionGetInfo (
+  IN     EFI_REGULAR_EXPRESSION_PROTOCOL  *This,
+  IN OUT UINTN                            *RegExSyntaxTypeListSize,
+  OUT    EFI_REGEX_SYNTAX_TYPE            *RegExSyntaxTypeList
+  )
+{
+  UINTN  SyntaxSize;
+  UINTN  Index;
+
+  if ((This == NULL) || (RegExSyntaxTypeListSize == NULL)) {
+    return EFI_INVALID_PARAMETER;
+  }
+
+  if ((*RegExSyntaxTypeListSize != 0) && (RegExSyntaxTypeList == NULL)) {
+    return EFI_INVALID_PARAMETER;
+  }
+
+  SyntaxSize = ARRAY_SIZE (mSupportedSyntaxes) * sizeof (**mSupportedSyntaxes);
+
+  if (*RegExSyntaxTypeListSize < SyntaxSize) {
+    *RegExSyntaxTypeListSize = SyntaxSize;
+    return EFI_BUFFER_TOO_SMALL;
+  }
+
+  for (Index = 0; Index < ARRAY_SIZE (mSupportedSyntaxes); ++Index) {
+    CopyMem (&RegExSyntaxTypeList[Index], mSupportedSyntaxes[Index], sizeof (**mSupportedSyntaxes));
+  }
+
+  *RegExSyntaxTypeListSize = SyntaxSize;
+
+  return EFI_SUCCESS;
+}
+
+/**
+  Checks if the input string matches to the regular expression pattern.
+
+  @param This          A pointer to the EFI_REGULAR_EXPRESSION_PROTOCOL instance.
+                       Type EFI_REGULAR_EXPRESSION_PROTOCOL is defined in Section
+                       XYZ.
+
+  @param String        A pointer to a NULL terminated string to match against the
+                       regular expression string specified by Pattern.
+
+  @param Pattern       A pointer to a NULL terminated string that represents the
+                       regular expression.
+
+  @param SyntaxType    A pointer to the EFI_REGEX_SYNTAX_TYPE that identifies the
+                       regular expression syntax type to use. May be NULL in which
+                       case the function will use its default regular expression
+                       syntax type.
+
+  @param Result        On return, points to TRUE if String fully matches against
+                       the regular expression Pattern using the regular expression
+                       SyntaxType. Otherwise, points to FALSE.
+
+  @param Captures      A Pointer to an array of EFI_REGEX_CAPTURE objects to receive
+                       the captured groups in the event of a match. The full
+                       sub-string match is put in Captures[0], and the results of N
+                       capturing groups are put in Captures[1:N]. If Captures is
+                       NULL, then this function doesn't allocate the memory for the
+                       array and does not build up the elements. It only returns the
+                       number of matching patterns in CapturesCount. If Captures is
+                       not NULL, this function returns a pointer to an array and
+                       builds up the elements in the array. CapturesCount is also
+                       updated to the number of matching patterns found. It is the
+                       caller's responsibility to free the memory pool in Captures
+                       and in each CapturePtr in the array elements.
+
+  @param CapturesCount On output, CapturesCount is the number of matching patterns
+                       found in String. Zero means no matching patterns were found
+                       in the string.
+
+  @retval EFI_SUCCESS            The regular expression string matching
+                                 completed successfully.
+  @retval EFI_UNSUPPORTED        The regular expression syntax specified by
+                                 SyntaxType is not supported by this driver.
+  @retval EFI_DEVICE_ERROR       The regular expression string matching
+                                 failed due to a hardware or firmware error.
+  @retval EFI_INVALID_PARAMETER  String, Pattern, Result, or CapturesCountis
+                                 NULL.
+
+**/
+EFI_STATUS
+EFIAPI
+RegularExpressionMatch (
+  IN  EFI_REGULAR_EXPRESSION_PROTOCOL  *This,
+  IN  CHAR16                           *String,
+  IN  CHAR16                           *Pattern,
+  IN  EFI_REGEX_SYNTAX_TYPE            *SyntaxType  OPTIONAL,
+  OUT BOOLEAN                          *Result,
+  OUT EFI_REGEX_CAPTURE                **Captures  OPTIONAL,
+  OUT UINTN                            *CapturesCount
+  )
+{
+  EFI_STATUS  Status;
+  UINT32      Index;
+  BOOLEAN     Supported;
+
+  if ((This == NULL) || (String == NULL) || (Pattern == NULL) || (Result == NULL) || (CapturesCount == NULL)) {
+    return EFI_INVALID_PARAMETER;
+  }
+
+  //
+  // Figure out which syntax to use
+  //
+  if (SyntaxType == NULL) {
+    SyntaxType = mSupportedSyntaxes[0];
+  } else {
+    Supported = FALSE;
+    for (Index = 0; Index < ARRAY_SIZE (mSupportedSyntaxes); ++Index) {
+      if (CompareGuid (SyntaxType, mSupportedSyntaxes[Index])) {
+        Supported = TRUE;
+        break;
+      }
+    }
+
+    if (!Supported) {
+      return EFI_UNSUPPORTED;
+    }
+  }
+
+  Status = OnigurumaMatch (String, Pattern, SyntaxType, Result, Captures, CapturesCount);
+
+  return Status;
+}
+
+/**
+  Entry point for RegularExpressionDxe.
+
+  @param ImageHandle     Image handle this driver.
+  @param SystemTable     Pointer to SystemTable.
+
+  @retval Status         Whether this function complete successfully.
+
+**/
+EFI_STATUS
+EFIAPI
+RegularExpressionDxeEntry (
+  IN  EFI_HANDLE        ImageHandle,
+  IN  EFI_SYSTEM_TABLE  *SystemTable
+  )
+{
+  EFI_STATUS  Status;
+
+  Status = gBS->InstallMultipleProtocolInterfaces (
+                  &ImageHandle,
+                  &gEfiRegularExpressionProtocolGuid,
+                  &mProtocolInstance,
+                  NULL
+                  );
+
+  return Status;
+}