diff options
Diffstat (limited to 'src/VBox/Devices/EFI/Firmware/MdeModulePkg/Universal/RegularExpressionDxe')
11 files changed, 891 insertions, 0 deletions
diff --git a/src/VBox/Devices/EFI/Firmware/MdeModulePkg/Universal/RegularExpressionDxe/OnigurumaUefiPort.c b/src/VBox/Devices/EFI/Firmware/MdeModulePkg/Universal/RegularExpressionDxe/OnigurumaUefiPort.c new file mode 100644 index 00000000..a5788673 --- /dev/null +++ b/src/VBox/Devices/EFI/Firmware/MdeModulePkg/Universal/RegularExpressionDxe/OnigurumaUefiPort.c @@ -0,0 +1,98 @@ +/** @file + + Module to rewrite stdlib references within Oniguruma + + (C) Copyright 2014-2015 Hewlett Packard Enterprise Development LP<BR> + Copyright (c) 2020, Intel Corporation. All rights reserved.<BR> + + SPDX-License-Identifier: BSD-2-Clause-Patent +**/ +#include "OnigurumaUefiPort.h" + +#define ONIGMEM_HEAD_SIGNATURE SIGNATURE_32('o','m','h','d') + +typedef struct { + UINT32 Signature; + UINTN Size; +} ONIGMEM_HEAD; + +#define ONIGMEM_OVERHEAD sizeof(ONIGMEM_HEAD) + +int EFIAPI sprintf_s(char *str, size_t sizeOfBuffer, char const *fmt, ...) +{ + VA_LIST Marker; + int NumberOfPrinted; + + VA_START (Marker, fmt); + NumberOfPrinted = (int)AsciiVSPrint (str, sizeOfBuffer, fmt, Marker); + VA_END (Marker); + + return NumberOfPrinted; +} + +int OnigStrCmp (const char* Str1, const char* Str2) +{ + return (int)AsciiStrCmp (Str1, Str2); +} + +int strlen(const char* str) +{ + return strlen_s(str, MAX_STRING_SIZE); +} + +void * malloc (size_t size) +{ + ONIGMEM_HEAD *PoolHdr; + UINTN NewSize; + VOID *Data; + + NewSize = (UINTN)(size) + ONIGMEM_OVERHEAD; + + Data = AllocatePool (NewSize); + if (Data != NULL) { + PoolHdr = (ONIGMEM_HEAD *)Data; + PoolHdr->Signature = ONIGMEM_HEAD_SIGNATURE; + PoolHdr->Size = size; + + return (VOID *)(PoolHdr + 1); + } + return NULL; +} + +void * realloc (void *ptr, size_t size) +{ + ONIGMEM_HEAD *OldPoolHdr; + ONIGMEM_HEAD *NewPoolHdr; + UINTN OldSize; + UINTN NewSize; + VOID *Data; + + NewSize = (UINTN)size + ONIGMEM_OVERHEAD; + Data = AllocatePool (NewSize); + if (Data != NULL) { + NewPoolHdr = (ONIGMEM_HEAD *)Data; + NewPoolHdr->Signature = ONIGMEM_HEAD_SIGNATURE; + NewPoolHdr->Size = size; + if (ptr != NULL) { + OldPoolHdr = (ONIGMEM_HEAD *)ptr - 1; + ASSERT (OldPoolHdr->Signature == ONIGMEM_HEAD_SIGNATURE); + OldSize = OldPoolHdr->Size; + + CopyMem ((VOID *)(NewPoolHdr + 1), ptr, MIN (OldSize, size)); + FreePool ((VOID *)OldPoolHdr); + } + return (VOID *)(NewPoolHdr + 1); + } + return NULL; +} + +void* memcpy (void *dest, const void *src, unsigned int count) +{ + return CopyMem (dest, src, (UINTN)count); +} + +void* memset (void *dest, char ch, unsigned int count) +{ + return SetMem (dest, count, ch); +} + diff --git a/src/VBox/Devices/EFI/Firmware/MdeModulePkg/Universal/RegularExpressionDxe/OnigurumaUefiPort.h b/src/VBox/Devices/EFI/Firmware/MdeModulePkg/Universal/RegularExpressionDxe/OnigurumaUefiPort.h new file mode 100644 index 00000000..8bf2b4b7 --- /dev/null +++ b/src/VBox/Devices/EFI/Firmware/MdeModulePkg/Universal/RegularExpressionDxe/OnigurumaUefiPort.h @@ -0,0 +1,104 @@ +/** @file + + Module to rewrite stdlib references within Oniguruma + + (C) Copyright 2014-2015 Hewlett Packard Enterprise Development LP<BR> + Copyright (c) 2020, Intel Corporation. All rights reserved.<BR> + + SPDX-License-Identifier: BSD-2-Clause-Patent +**/ +#ifndef ONIGURUMA_UEFI_PORT_H +#define ONIGURUMA_UEFI_PORT_H + +#include <Library/MemoryAllocationLib.h> +#include <Library/PrintLib.h> +#include <Library/BaseMemoryLib.h> +#include <Library/BaseLib.h> +#include <Library/DebugLib.h> + + +#define ONIG_NO_STANDARD_C_HEADERS +#define ONIG_NO_PRINT +#define P_(args) args + +#define INT_MAX 0x7FFFFFFF +#define LONG_MAX 0x7FFFFFFF +#define UINT_MAX 0xFFFFFFFF +#define ULONG_MAX 0xFFFFFFFF + + +#define SIZEOF_LONG 4 +#define SIZEOF_LONG_LONG 8 +typedef UINTN size_t; +typedef UINT32 uint32_t; +typedef INTN intptr_t; + +#ifndef offsetof +#define offsetof OFFSET_OF +#endif + +#ifdef MDE_CPU_IA32 +#define SIZEOF_VOIDP 4 +#endif + +#ifdef MDE_CPU_X64 +#define SIZEOF_VOIDP 8 +#endif + +#define calloc(n,s) AllocateZeroPool((n)*(s)) + +#define free(p) \ + do { \ + VOID *EvalOnce; \ + \ + EvalOnce = (p); \ + if (EvalOnce != NULL) { \ + FreePool (EvalOnce); \ + } \ + } while (FALSE) + +#define xmemmove(Dest,Src,Length) CopyMem(Dest,Src,Length) +#define xmemcpy(Dest,Src,Length) CopyMem(Dest,Src,Length) +#define xmemset(Buffer,Value,Length) SetMem(Buffer,Length,Value) + +#define va_init_list(a,b) VA_START(a,b) +#define va_list VA_LIST +#define va_arg(a,b) VA_ARG(a,b) +#define va_end(a) VA_END(a) +#define va_start VA_START + +#define FILE VOID +#define stdout NULL +#define fprintf(...) +#define fputs(a,b) +#define vsnprintf (int)AsciiVSPrint +#define _vsnprintf vsnprintf +#define xsnprintf sprintf_s +#define xvsnprintf vsnprintf +#define alloca malloc + +#define setlocale(a,b) +#define LC_ALL 0 + +#define UCHAR_MAX 255 +#define MAX_STRING_SIZE 0x1000 +#define strlen_s(String,MaxSize) AsciiStrnLenS (String, MaxSize) +#define xstrncpy(Dest, Src, MaxSize) strcat_s(Dest,MaxSize,Src) +#define xstrcat(Dest,Src,MaxSize) strcat(Dest,Src,MaxSize) +#define strcat(Dest,Src,MaxSize) strcat_s(Dest,MaxSize,Src) +#define strcat_s(Dest,MaxSize,Src) AsciiStrCatS (Dest, MaxSize, Src) +#define strncpy_s(Dest,MaxSize,Src,Length) AsciiStrnCpyS (Dest, MaxSize, Src, Length) +#define strcmp OnigStrCmp + +int OnigStrCmp (const char* Str1, const char* Str2); + +int EFIAPI sprintf_s (char *str, size_t sizeOfBuffer, char const *fmt, ...); +int strlen(const char* str); +void* malloc(size_t size); +void* realloc(void *ptr, size_t size); +void* memcpy (void *dest, const void *src, unsigned int count); +void* memset (void *dest, char ch, unsigned int count); + +#define exit(n) ASSERT(FALSE); + +#endif // !ONIGURUMA_UEFI_PORT_H diff --git a/src/VBox/Devices/EFI/Firmware/MdeModulePkg/Universal/RegularExpressionDxe/RegularExpressionDxe.c b/src/VBox/Devices/EFI/Firmware/MdeModulePkg/Universal/RegularExpressionDxe/RegularExpressionDxe.c new file mode 100644 index 00000000..1c4c5941 --- /dev/null +++ b/src/VBox/Devices/EFI/Firmware/MdeModulePkg/Universal/RegularExpressionDxe/RegularExpressionDxe.c @@ -0,0 +1,381 @@ +/** @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; +} diff --git a/src/VBox/Devices/EFI/Firmware/MdeModulePkg/Universal/RegularExpressionDxe/RegularExpressionDxe.h b/src/VBox/Devices/EFI/Firmware/MdeModulePkg/Universal/RegularExpressionDxe/RegularExpressionDxe.h new file mode 100644 index 00000000..9fb4ac22 --- /dev/null +++ b/src/VBox/Devices/EFI/Firmware/MdeModulePkg/Universal/RegularExpressionDxe/RegularExpressionDxe.h @@ -0,0 +1,125 @@ +/** @file + EFI_REGULAR_EXPRESSION_PROTOCOL Header File. + + (C) Copyright 2015 Hewlett Packard Enterprise Development LP<BR> + Copyright (c) 2020, Intel Corporation. All rights reserved.<BR> + + SPDX-License-Identifier: BSD-2-Clause-Patent + +**/ + +#ifndef __REGULAR_EXPRESSIONDXE_H__ +#define __REGULAR_EXPRESSIONDXE_H__ + +#include "oniguruma/src/oniguruma.h" + +#include <Uefi.h> +#include <Protocol/RegularExpressionProtocol.h> +#include <Library/UefiBootServicesTableLib.h> +#include <Library/BaseMemoryLib.h> +#include <Library/MemoryAllocationLib.h> +#include <Library/DebugLib.h> +#include <Library/BaseLib.h> + +/** + 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 + ); + +/** + 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 + ); + +#endif diff --git a/src/VBox/Devices/EFI/Firmware/MdeModulePkg/Universal/RegularExpressionDxe/RegularExpressionDxe.inf b/src/VBox/Devices/EFI/Firmware/MdeModulePkg/Universal/RegularExpressionDxe/RegularExpressionDxe.inf new file mode 100644 index 00000000..2c367e62 --- /dev/null +++ b/src/VBox/Devices/EFI/Firmware/MdeModulePkg/Universal/RegularExpressionDxe/RegularExpressionDxe.inf @@ -0,0 +1,129 @@ +## @file +# EFI_REGULAR_EXPRESSION_PROTOCOL Implementation +# +# Copyright (c) 2018-2020, Intel Corporation. All rights reserved.<BR> +# (C) Copyright 2015 Hewlett Packard Enterprise Development LP<BR> +# +# SPDX-License-Identifier: BSD-2-Clause-Patent +## + +[Defines] + INF_VERSION = 0x00010018 + BASE_NAME = RegularExpressionDxe + FILE_GUID = 3E197E9C-D8DC-42D3-89CE-B04FA9833756 + MODULE_TYPE = UEFI_DRIVER + VERSION_STRING = 1.0 + ENTRY_POINT = RegularExpressionDxeEntry + +[Sources] + RegularExpressionDxe.c + RegularExpressionDxe.h + OnigurumaUefiPort.h + OnigurumaUefiPort.c + +# Wrapper header files start # + stdio.h + stdarg.h + stddef.h + stdlib.h + string.h + config.h +# Wrapper header files end # + +# Upstream Oniguruma code + oniguruma/src/onig_init.c + oniguruma/src/oniguruma.h + oniguruma/src/regcomp.c + oniguruma/src/regenc.c + oniguruma/src/regenc.h + oniguruma/src/regerror.c + oniguruma/src/regexec.c + oniguruma/src/oniggnu.h + oniguruma/src/reggnu.c + oniguruma/src/regint.h + oniguruma/src/regparse.c + oniguruma/src/regparse.h + oniguruma/src/regposerr.c + oniguruma/src/onigposix.h + oniguruma/src/regposix.c + oniguruma/src/regsyntax.c + oniguruma/src/regtrav.c + oniguruma/src/regversion.c + oniguruma/src/st.c + oniguruma/src/st.h + +# Supported Character Encodings + oniguruma/src/ascii.c + oniguruma/src/unicode.c + oniguruma/src/unicode_fold1_key.c + oniguruma/src/unicode_fold2_key.c + oniguruma/src/unicode_fold3_key.c + oniguruma/src/unicode_unfold_key.c + oniguruma/src/utf16_le.c + oniguruma/src/utf8.c + oniguruma/src/utf16_be.c + oniguruma/src/euc_jp.c + oniguruma/src/sjis.c + oniguruma/src/sjis_prop.c + oniguruma/src/euc_jp_prop.c + +[Packages] + MdePkg/MdePkg.dec + MdeModulePkg/MdeModulePkg.dec + +[LibraryClasses] + UefiBootServicesTableLib + UefiDriverEntryPoint + MemoryAllocationLib + BaseMemoryLib + DebugLib + PrintLib + +[Guids] + gEfiRegexSyntaxTypePosixExtendedGuid ## CONSUMES ## GUID + gEfiRegexSyntaxTypePerlGuid ## CONSUMES ## GUID + +[Protocols] + gEfiRegularExpressionProtocolGuid ## PRODUCES + +[BuildOptions] + # Enable STDARG for variable arguments + *_*_*_CC_FLAGS = -DHAVE_STDARG_H -U_WIN32 -DONIG_VARIADIC_FUNC_ATTR=EFIAPI + + # Override MSFT build option to remove /Oi and /GL + MSFT:*_*_*_CC_FLAGS = /GL- + INTEL:*_*_*_CC_FLAGS = /Oi- + + # Oniguruma: potentially uninitialized local variable used + MSFT:*_*_*_CC_FLAGS = /wd4701 /wd4703 + + # Oniguruma: intrinsic function not declared + MSFT:*_*_*_CC_FLAGS = /wd4164 + + # Oniguruma: old style declaration in st.c + MSFT:*_*_*_CC_FLAGS = /wd4131 + + # Oniguruma: 'type cast' : truncation from 'OnigUChar *' to 'unsigned int' + MSFT:*_*_*_CC_FLAGS = /wd4305 /wd4306 + + # Oniguruma: nameless union declared in regparse.h + MSFT:*_*_*_CC_FLAGS = /wd4201 + + # Oniguruma: 'type cast' : "int" to "OnigUChar", function pointer to "void *" + MSFT:*_*_*_CC_FLAGS = /wd4244 /wd4054 + + # Oniguruma: previous local declaration + MSFT:*_*_*_CC_FLAGS = /wd4456 + + # Oniguruma: signed and unsigned mismatch/cast + MSFT:*_*_*_CC_FLAGS = /wd4018 /wd4245 /wd4389 /wd4090 + + # Oniguruma: tag_end in parse_callout_of_name + GCC:*_*_*_CC_FLAGS = -Wno-error=maybe-uninitialized + + # Oniguruma: implicit conversion from 'UINTN' (aka 'unsigned long long') to 'long' + GCC:*_CLANGPDB_*_CC_FLAGS = -Wno-error=constant-conversion + + # Not add -Wno-error=maybe-uninitialized option for XCODE + # XCODE doesn't know this option + XCODE:*_*_*_CC_FLAGS = diff --git a/src/VBox/Devices/EFI/Firmware/MdeModulePkg/Universal/RegularExpressionDxe/config.h b/src/VBox/Devices/EFI/Firmware/MdeModulePkg/Universal/RegularExpressionDxe/config.h new file mode 100644 index 00000000..130f70d0 --- /dev/null +++ b/src/VBox/Devices/EFI/Firmware/MdeModulePkg/Universal/RegularExpressionDxe/config.h @@ -0,0 +1,9 @@ +/** @file + Include file to support building the third-party oniguruma. + +Copyright (c) 2020, Intel Corporation. All rights reserved.<BR> +SPDX-License-Identifier: BSD-2-Clause-Patent + +**/ + +#include <OnigurumaUefiPort.h> diff --git a/src/VBox/Devices/EFI/Firmware/MdeModulePkg/Universal/RegularExpressionDxe/stdarg.h b/src/VBox/Devices/EFI/Firmware/MdeModulePkg/Universal/RegularExpressionDxe/stdarg.h new file mode 100644 index 00000000..130f70d0 --- /dev/null +++ b/src/VBox/Devices/EFI/Firmware/MdeModulePkg/Universal/RegularExpressionDxe/stdarg.h @@ -0,0 +1,9 @@ +/** @file + Include file to support building the third-party oniguruma. + +Copyright (c) 2020, Intel Corporation. All rights reserved.<BR> +SPDX-License-Identifier: BSD-2-Clause-Patent + +**/ + +#include <OnigurumaUefiPort.h> diff --git a/src/VBox/Devices/EFI/Firmware/MdeModulePkg/Universal/RegularExpressionDxe/stddef.h b/src/VBox/Devices/EFI/Firmware/MdeModulePkg/Universal/RegularExpressionDxe/stddef.h new file mode 100644 index 00000000..130f70d0 --- /dev/null +++ b/src/VBox/Devices/EFI/Firmware/MdeModulePkg/Universal/RegularExpressionDxe/stddef.h @@ -0,0 +1,9 @@ +/** @file + Include file to support building the third-party oniguruma. + +Copyright (c) 2020, Intel Corporation. All rights reserved.<BR> +SPDX-License-Identifier: BSD-2-Clause-Patent + +**/ + +#include <OnigurumaUefiPort.h> diff --git a/src/VBox/Devices/EFI/Firmware/MdeModulePkg/Universal/RegularExpressionDxe/stdio.h b/src/VBox/Devices/EFI/Firmware/MdeModulePkg/Universal/RegularExpressionDxe/stdio.h new file mode 100644 index 00000000..130f70d0 --- /dev/null +++ b/src/VBox/Devices/EFI/Firmware/MdeModulePkg/Universal/RegularExpressionDxe/stdio.h @@ -0,0 +1,9 @@ +/** @file + Include file to support building the third-party oniguruma. + +Copyright (c) 2020, Intel Corporation. All rights reserved.<BR> +SPDX-License-Identifier: BSD-2-Clause-Patent + +**/ + +#include <OnigurumaUefiPort.h> diff --git a/src/VBox/Devices/EFI/Firmware/MdeModulePkg/Universal/RegularExpressionDxe/stdlib.h b/src/VBox/Devices/EFI/Firmware/MdeModulePkg/Universal/RegularExpressionDxe/stdlib.h new file mode 100644 index 00000000..130f70d0 --- /dev/null +++ b/src/VBox/Devices/EFI/Firmware/MdeModulePkg/Universal/RegularExpressionDxe/stdlib.h @@ -0,0 +1,9 @@ +/** @file + Include file to support building the third-party oniguruma. + +Copyright (c) 2020, Intel Corporation. All rights reserved.<BR> +SPDX-License-Identifier: BSD-2-Clause-Patent + +**/ + +#include <OnigurumaUefiPort.h> diff --git a/src/VBox/Devices/EFI/Firmware/MdeModulePkg/Universal/RegularExpressionDxe/string.h b/src/VBox/Devices/EFI/Firmware/MdeModulePkg/Universal/RegularExpressionDxe/string.h new file mode 100644 index 00000000..130f70d0 --- /dev/null +++ b/src/VBox/Devices/EFI/Firmware/MdeModulePkg/Universal/RegularExpressionDxe/string.h @@ -0,0 +1,9 @@ +/** @file + Include file to support building the third-party oniguruma. + +Copyright (c) 2020, Intel Corporation. All rights reserved.<BR> +SPDX-License-Identifier: BSD-2-Clause-Patent + +**/ + +#include <OnigurumaUefiPort.h> |