From mboxrd@z Thu Jan 1 00:00:00 1970 Received: from wout3-smtp.messagingengine.com (wout3-smtp.messagingengine.com [64.147.123.19]) by mx.groups.io with SMTP id smtpd.web10.35244.1677286490987059198 for ; Fri, 24 Feb 2023 16:54:51 -0800 Authentication-Results: mx.groups.io; dkim=fail reason="signature has expired" header.i=@bsdio.com header.s=fm2 header.b=KFRlRB49; spf=pass (domain: bsdio.com, ip: 64.147.123.19, mailfrom: rebecca@bsdio.com) Received: from compute5.internal (compute5.nyi.internal [10.202.2.45]) by mailout.west.internal (Postfix) with ESMTP id EF306320024A; Fri, 24 Feb 2023 19:54:49 -0500 (EST) Received: from mailfrontend2 ([10.202.2.163]) by compute5.internal (MEProxy); Fri, 24 Feb 2023 19:54:50 -0500 DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=bsdio.com; h=cc :cc:content-transfer-encoding:date:date:from:from:in-reply-to :in-reply-to:message-id:mime-version:references:reply-to:sender :subject:subject:to:to; s=fm2; t=1677286489; x=1677372889; bh=ZL qjFEskBI5G7IiBJwZtJhJyabUsyPAW+4In+bu2dvk=; b=KFRlRB49abNst2YbsI 8JAGJCiRS4996+nLXsRxjMRTvBwq9sAWdjcSDxoydL3xecqFIdJnvhswoi11dJvs BsJ3yFU0eRx6h1kxg3zubu1W0rV5WJWV4yHPfBgAbvNvKGqIJmmPkrsf5aprPfEj Mk65O2QSgQzmLyfMcuG4DguH7GnGaSo0eD7HypaGTo/FSzUO4ix0Y8Nu4YI93P3D /8WeDMVCTmG2+YwmYt0vAkCzA7LXcUdpt2gykCXokh0+fBuWxinuIGcas67JNvDs ymFKvgSaKMMHHdQXqU+Uoa2YYoA1NwG743lwp6dqDnVtn8HPCyvi3ynCUaV2cyiU i4lQ== DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d= messagingengine.com; h=cc:cc:content-transfer-encoding:date:date :feedback-id:feedback-id:from:from:in-reply-to:in-reply-to :message-id:mime-version:references:reply-to:sender:subject :subject:to:to:x-me-proxy:x-me-proxy:x-me-sender:x-me-sender :x-sasl-enc; s=fm1; t=1677286489; x=1677372889; bh=ZLqjFEskBI5G7 IiBJwZtJhJyabUsyPAW+4In+bu2dvk=; b=OZYA3V3pmryhA1URXIO2tJuutcseL pGrOPjetEtEjydOvLNwdkSdAip0FnBJDFPanaMFHWMJ4HpdNaPxby9oHZmKvbRLd df2FgjDL87DmJbAHHNTtgwXgzqRzxa3RH5rQtzom6HUhrfuUFGr4ZqeKKGx5e3VI twIgu38wfyDzJ9DWTFJp/hOuU1Qway2qvKg4yefRK3hjc0qU9aNb1+XzfItHwrjw rOMw3VHUYgdzXEfhobp1u9T2g0387haLPvi6tS5FnlFEyVX+UjIgQWUTlveId4js SYc8yP4lHxpFEFtv4i+kqKeDgl5EtDDqAbFV0LA2+qO9soEjR8ilIpcIw== X-ME-Sender: X-ME-Received: X-ME-Proxy-Cause: gggruggvucftvghtrhhoucdtuddrgedvhedrudekgedgvdeiucetufdoteggodetrfdotf fvucfrrhhofhhilhgvmecuhfgrshhtofgrihhlpdfqfgfvpdfurfetoffkrfgpnffqhgen uceurghilhhouhhtmecufedttdenucesvcftvggtihhpihgvnhhtshculddquddttddmne cujfgurhephffvvefufffkofgjfhgggfestdekredtredttdenucfhrhhomheptfgvsggv tggtrgcuvehrrghnuceorhgvsggvtggtrgessghsughiohdrtghomheqnecuggftrfgrth htvghrnhepgeffueeuledvgefgvddvgfetvdduhfefkedukeeikedtudekfeetteeifedv leefnecuvehluhhsthgvrhfuihiivgeptdenucfrrghrrghmpehmrghilhhfrhhomheprh gvsggvtggtrgessghsughiohdrtghomh X-ME-Proxy: Feedback-ID: i5b994698:Fastmail Received: by mail.messagingengine.com (Postfix) with ESMTPA; Fri, 24 Feb 2023 19:54:48 -0500 (EST) From: "Rebecca Cran" To: devel@edk2.groups.io, Bob Feng , Liming Gao , Yuwei Chen Cc: Rebecca Cran Subject: [PATCH 3/3] BaseTools: Run Uncrustify over files in Source/C/Common Date: Fri, 24 Feb 2023 17:54:31 -0700 Message-Id: <20230225005431.12173-4-rebecca@bsdio.com> X-Mailer: git-send-email 2.37.1 (Apple Git-137.1) In-Reply-To: <20230225005431.12173-1-rebecca@bsdio.com> References: <20230225005431.12173-1-rebecca@bsdio.com> MIME-Version: 1.0 Content-Transfer-Encoding: 8bit Reformat the files in Source/C/Common by running Uncrustify on them. Signed-off-by: Rebecca Cran --- BaseTools/Source/C/Common/BinderFuncs.h | 27 +- BaseTools/Source/C/Common/CommonLib.h | 259 +++--- BaseTools/Source/C/Common/Crc32.h | 6 +- BaseTools/Source/C/Common/Decompress.h | 4 +- BaseTools/Source/C/Common/EfiUtilityMsgs.h | 38 +- BaseTools/Source/C/Common/FirmwareVolumeBufferLib.h | 101 ++- BaseTools/Source/C/Common/FvLib.h | 51 +- BaseTools/Source/C/Common/MemoryFile.h | 16 +- BaseTools/Source/C/Common/MyAlloc.h | 50 +- BaseTools/Source/C/Common/OsPath.h | 14 +- BaseTools/Source/C/Common/ParseGuidedSectionTools.h | 12 +- BaseTools/Source/C/Common/ParseInf.h | 28 +- BaseTools/Source/C/Common/PcdValueCommon.h | 22 +- BaseTools/Source/C/Common/PeCoffLib.h | 66 +- BaseTools/Source/C/Common/SimpleFileParsing.h | 24 +- BaseTools/Source/C/Common/StringFuncs.h | 42 +- BaseTools/Source/C/Common/WinNtInclude.h | 28 +- BaseTools/Source/C/Common/BasePeCoff.c | 868 ++++++++++---------- BaseTools/Source/C/Common/BinderFuncs.c | 31 +- BaseTools/Source/C/Common/CommonLib.c | 584 +++++++------ BaseTools/Source/C/Common/Crc32.c | 8 +- BaseTools/Source/C/Common/Decompress.c | 325 ++++---- BaseTools/Source/C/Common/EfiCompress.c | 679 ++++++++------- BaseTools/Source/C/Common/EfiUtilityMsgs.c | 173 ++-- BaseTools/Source/C/Common/FirmwareVolumeBuffer.c | 617 +++++++------- BaseTools/Source/C/Common/FvLib.c | 261 +++--- BaseTools/Source/C/Common/MemoryFile.c | 55 +- BaseTools/Source/C/Common/MyAlloc.c | 110 +-- BaseTools/Source/C/Common/OsPath.c | 91 +- BaseTools/Source/C/Common/ParseGuidedSectionTools.c | 54 +- BaseTools/Source/C/Common/ParseInf.c | 184 +++-- BaseTools/Source/C/Common/PcdValueCommon.c | 315 +++---- BaseTools/Source/C/Common/PeCoffLoaderEx.c | 217 +++-- BaseTools/Source/C/Common/SimpleFileParsing.c | 325 ++++---- BaseTools/Source/C/Common/StringFuncs.c | 90 +- BaseTools/Source/C/Common/TianoCompress.c | 477 +++++------ 36 files changed, 3269 insertions(+), 2983 deletions(-) diff --git a/BaseTools/Source/C/Common/BinderFuncs.h b/BaseTools/Source/C/Common/BinderFuncs.h index ceaa9cd318ff..138356d340df 100644 --- a/BaseTools/Source/C/Common/BinderFuncs.h +++ b/BaseTools/Source/C/Common/BinderFuncs.h @@ -22,40 +22,39 @@ SPDX-License-Identifier: BSD-2-Clause-Patent VOID * CommonLibBinderAllocate ( - IN UINTN Size + IN UINTN Size ); VOID CommonLibBinderFree ( - IN VOID *Pointer + IN VOID *Pointer ); VOID CommonLibBinderCopyMem ( - IN VOID *Destination, - IN VOID *Source, - IN UINTN Length + IN VOID *Destination, + IN VOID *Source, + IN UINTN Length ); VOID CommonLibBinderSetMem ( - IN VOID *Destination, - IN UINTN Length, - IN UINT8 Value + IN VOID *Destination, + IN UINTN Length, + IN UINT8 Value ); INTN CommonLibBinderCompareMem ( - IN VOID *MemOne, - IN VOID *MemTwo, - IN UINTN Length + IN VOID *MemOne, + IN VOID *MemTwo, + IN UINTN Length ); BOOLEAN CommonLibBinderCompareGuid ( - IN EFI_GUID *Guid1, - IN EFI_GUID *Guid2 + IN EFI_GUID *Guid1, + IN EFI_GUID *Guid2 ); #endif // #ifndef CommonLibs_h_INCLUDED - diff --git a/BaseTools/Source/C/Common/CommonLib.h b/BaseTools/Source/C/Common/CommonLib.h index a841029c2aaa..65a3c2ebd783 100644 --- a/BaseTools/Source/C/Common/CommonLib.h +++ b/BaseTools/Source/C/Common/CommonLib.h @@ -13,35 +13,35 @@ SPDX-License-Identifier: BSD-2-Clause-Patent #include #include #ifndef _WIN32 -#include + #include #endif #define PRINTED_GUID_BUFFER_SIZE 37 // including null-termination #ifdef PATH_MAX -#define MAX_LONG_FILE_PATH PATH_MAX +#define MAX_LONG_FILE_PATH PATH_MAX #else -#define MAX_LONG_FILE_PATH 500 +#define MAX_LONG_FILE_PATH 500 #endif -#define MAX_UINT64 ((UINT64)0xFFFFFFFFFFFFFFFFULL) -#define MAX_UINT32 ((UINT32)0xFFFFFFFF) +#define MAX_UINT64 ((UINT64)0xFFFFFFFFFFFFFFFFULL) +#define MAX_UINT32 ((UINT32)0xFFFFFFFF) #define MAX_UINT16 ((UINT16)0xFFFF) #define MAX_UINT8 ((UINT8)0xFF) -#define ARRAY_SIZE(Array) (sizeof (Array) / sizeof ((Array)[0])) -#define ASCII_RSIZE_MAX 1000000 +#define ARRAY_SIZE(Array) (sizeof (Array) / sizeof ((Array)[0])) +#define ASCII_RSIZE_MAX 1000000 #undef RSIZE_MAX -#define RSIZE_MAX 1000000 +#define RSIZE_MAX 1000000 -#define IS_COMMA(a) ((a) == L',') -#define IS_HYPHEN(a) ((a) == L'-') -#define IS_DOT(a) ((a) == L'.') -#define IS_LEFT_PARENTH(a) ((a) == L'(') -#define IS_RIGHT_PARENTH(a) ((a) == L')') -#define IS_SLASH(a) ((a) == L'/') -#define IS_NULL(a) ((a) == L'\0') +#define IS_COMMA(a) ((a) == L',') +#define IS_HYPHEN(a) ((a) == L'-') +#define IS_DOT(a) ((a) == L'.') +#define IS_LEFT_PARENTH(a) ((a) == L'(') +#define IS_RIGHT_PARENTH(a) ((a) == L')') +#define IS_SLASH(a) ((a) == L'/') +#define IS_NULL(a) ((a) == L'\0') -#define ASSERT(x) assert(x) +#define ASSERT(x) assert(x) #ifdef __cplusplus extern "C" { @@ -82,8 +82,8 @@ CopyMem ( INTN CompareGuid ( - IN EFI_GUID *Guid1, - IN EFI_GUID *Guid2 + IN EFI_GUID *Guid1, + IN EFI_GUID *Guid2 ) ; @@ -117,64 +117,64 @@ Routine Description: **/ EFI_STATUS PutFileImage ( - IN CHAR8 *OutputFileName, - IN CHAR8 *OutputFileImage, - IN UINT32 BytesToWrite + IN CHAR8 *OutputFileName, + IN CHAR8 *OutputFileImage, + IN UINT32 BytesToWrite ) ; UINT8 CalculateChecksum8 ( - IN UINT8 *Buffer, - IN UINTN Size + IN UINT8 *Buffer, + IN UINTN Size ) ; UINT8 CalculateSum8 ( - IN UINT8 *Buffer, - IN UINTN Size + IN UINT8 *Buffer, + IN UINTN Size ) ; UINT16 CalculateChecksum16 ( - IN UINT16 *Buffer, - IN UINTN Size + IN UINT16 *Buffer, + IN UINTN Size ) ; UINT16 CalculateSum16 ( - IN UINT16 *Buffer, - IN UINTN Size + IN UINT16 *Buffer, + IN UINTN Size ) ; EFI_STATUS PrintGuid ( - IN EFI_GUID *Guid + IN EFI_GUID *Guid ) ; #define PRINTED_GUID_BUFFER_SIZE 37 // including null-termination EFI_STATUS PrintGuidToBuffer ( - IN EFI_GUID *Guid, - IN OUT UINT8 *Buffer, - IN UINT32 BufferLen, - IN BOOLEAN Uppercase + IN EFI_GUID *Guid, + IN OUT UINT8 *Buffer, + IN UINT32 BufferLen, + IN BOOLEAN Uppercase ) ; CHAR8 * LongFilePath ( - IN CHAR8 *FileName -); + IN CHAR8 *FileName + ); UINTN StrLen ( - CONST CHAR16 *String + CONST CHAR16 *String ); VOID * @@ -185,177 +185,178 @@ AllocateCopyPool ( INTN StrnCmp ( - CONST CHAR16 *FirstString, - CONST CHAR16 *SecondString, - UINTN Length + CONST CHAR16 *FirstString, + CONST CHAR16 *SecondString, + UINTN Length ); RETURN_STATUS StrToGuid ( - CONST CHAR16 *String, - EFI_GUID *Guid + CONST CHAR16 *String, + EFI_GUID *Guid ); RETURN_STATUS StrHexToBytes ( - CONST CHAR16 *String, - UINTN Length, - UINT8 *Buffer, - UINTN MaxBufferSize + CONST CHAR16 *String, + UINTN Length, + UINT8 *Buffer, + UINTN MaxBufferSize ); UINTN InternalHexCharToUintn ( - CHAR16 Char + CHAR16 Char ); VOID * InternalAllocateCopyPool ( - UINTN AllocationSize, - CONST VOID *Buffer + UINTN AllocationSize, + CONST VOID *Buffer ); BOOLEAN InternalIsDecimalDigitCharacter ( - CHAR16 Char + CHAR16 Char ); UINT32 SwapBytes32 ( - UINT32 Value + UINT32 Value ); UINT16 SwapBytes16 ( - UINT16 Value + UINT16 Value ); EFI_GUID * CopyGuid ( - EFI_GUID *DestinationGuid, - CONST EFI_GUID *SourceGuid + EFI_GUID *DestinationGuid, + CONST EFI_GUID *SourceGuid ); UINT64 WriteUnaligned64 ( - UINT64 *Buffer, - UINT64 Value + UINT64 *Buffer, + UINT64 Value ); UINT64 ReadUnaligned64 ( - CONST UINT64 *Buffer + CONST UINT64 *Buffer ); UINTN StrSize ( - CONST CHAR16 *String + CONST CHAR16 *String ); UINT64 StrHexToUint64 ( - CONST CHAR16 *String + CONST CHAR16 *String ); UINT64 StrDecimalToUint64 ( - CONST CHAR16 *String + CONST CHAR16 *String ); RETURN_STATUS StrHexToUint64S ( - CONST CHAR16 *String, - CHAR16 **EndPointer, - UINT64 *Data + CONST CHAR16 *String, + CHAR16 **EndPointer, + UINT64 *Data ); RETURN_STATUS StrDecimalToUint64S ( - CONST CHAR16 *String, - CHAR16 **EndPointer, OPTIONAL - UINT64 *Data + CONST CHAR16 *String, + CHAR16 **EndPointer, OPTIONAL + UINT64 *Data ); VOID * ReallocatePool ( - UINTN OldSize, - UINTN NewSize, - VOID *OldBuffer OPTIONAL + UINTN OldSize, + UINTN NewSize, + VOID *OldBuffer OPTIONAL ); VOID * InternalReallocatePool ( - UINTN OldSize, - UINTN NewSize, - VOID *OldBuffer OPTIONAL + UINTN OldSize, + UINTN NewSize, + VOID *OldBuffer OPTIONAL ); VOID * InternalAllocateZeroPool ( - UINTN AllocationSize - ) ; + UINTN AllocationSize + ); VOID * InternalAllocatePool ( - UINTN AllocationSize + UINTN AllocationSize ); UINTN StrnLenS ( - CONST CHAR16 *String, - UINTN MaxSize + CONST CHAR16 *String, + UINTN MaxSize ); CHAR16 InternalCharToUpper ( - CHAR16 Char + CHAR16 Char ); INTN StrCmp ( - CONST CHAR16 *FirstString, - CONST CHAR16 *SecondString + CONST CHAR16 *FirstString, + CONST CHAR16 *SecondString ); UINT64 SwapBytes64 ( - UINT64 Value + UINT64 Value ); UINT64 InternalMathSwapBytes64 ( - UINT64 Operand + UINT64 Operand ); RETURN_STATUS StrToIpv4Address ( - CONST CHAR16 *String, - CHAR16 **EndPointer, - EFI_IPv4_ADDRESS *Address, - UINT8 *PrefixLength + CONST CHAR16 *String, + CHAR16 **EndPointer, + EFI_IPv4_ADDRESS *Address, + UINT8 *PrefixLength ); RETURN_STATUS StrToIpv6Address ( - CONST CHAR16 *String, - CHAR16 **EndPointer, - EFI_IPv6_ADDRESS *Address, - UINT8 *PrefixLength + CONST CHAR16 *String, + CHAR16 **EndPointer, + EFI_IPv6_ADDRESS *Address, + UINT8 *PrefixLength ); RETURN_STATUS StrCpyS ( - CHAR16 *Destination, - UINTN DestMax, - CONST CHAR16 *Source + CHAR16 *Destination, + UINTN DestMax, + CONST CHAR16 *Source ); RETURN_STATUS UnicodeStrToAsciiStrS ( - CONST CHAR16 *Source, - CHAR8 *Destination, - UINTN DestMax + CONST CHAR16 *Source, + CHAR8 *Destination, + UINTN DestMax ); + VOID * AllocatePool ( UINTN AllocationSize @@ -363,13 +364,13 @@ AllocatePool ( UINT16 WriteUnaligned16 ( - UINT16 *Buffer, - UINT16 Value + UINT16 *Buffer, + UINT16 Value ); UINT16 ReadUnaligned16 ( - CONST UINT16 *Buffer + CONST UINT16 *Buffer ); VOID * @@ -379,15 +380,15 @@ AllocateZeroPool ( BOOLEAN InternalIsHexaDecimalDigitCharacter ( - CHAR16 Char + CHAR16 Char ); BOOLEAN InternalSafeStringIsOverlap ( - IN VOID *Base1, - IN UINTN Size1, - IN VOID *Base2, - IN UINTN Size2 + IN VOID *Base1, + IN UINTN Size1, + IN VOID *Base2, + IN UINTN Size2 ); BOOLEAN @@ -400,30 +401,30 @@ InternalSafeStringNoStrOverlap ( BOOLEAN IsHexStr ( - CHAR16 *Str + CHAR16 *Str ); UINTN Strtoi ( - CHAR16 *Str + CHAR16 *Str ); VOID Strtoi64 ( - CHAR16 *Str, - UINT64 *Data + CHAR16 *Str, + UINT64 *Data ); VOID StrToAscii ( - CHAR16 *Str, - CHAR8 **AsciiStr + CHAR16 *Str, + CHAR8 **AsciiStr ); CHAR16 * SplitStr ( - CHAR16 **List, - CHAR16 Separator + CHAR16 **List, + CHAR16 Separator ); /*++ @@ -444,26 +445,34 @@ Routine Description: #endif #ifdef __GNUC__ -#include -#include -#define stricmp strcasecmp -#define _stricmp strcasecmp -#define strnicmp strncasecmp -#define strcmpi strcasecmp -size_t _filelength(int fd); -#ifndef __CYGWIN__ -char *strlwr(char *s); -#endif + #include + #include +#define stricmp strcasecmp +#define _stricmp strcasecmp +#define strnicmp strncasecmp +#define strcmpi strcasecmp +size_t +_filelength ( + int fd + ); + + #ifndef __CYGWIN__ +char * +strlwr ( + char *s + ); + + #endif #endif // // On windows, mkdir only has one parameter. // On unix, it has two parameters // -#if defined(__GNUC__) -#define mkdir(dir, perm) mkdir(dir, perm) +#if defined (__GNUC__) +#define mkdir(dir, perm) mkdir(dir, perm) #else -#define mkdir(dir, perm) mkdir(dir) +#define mkdir(dir, perm) mkdir(dir) #endif #endif diff --git a/BaseTools/Source/C/Common/Crc32.h b/BaseTools/Source/C/Common/Crc32.h index 3f6b5b35fc36..a5946f961d45 100644 --- a/BaseTools/Source/C/Common/Crc32.h +++ b/BaseTools/Source/C/Common/Crc32.h @@ -24,9 +24,9 @@ SPDX-License-Identifier: BSD-2-Clause-Patent **/ EFI_STATUS CalculateCrc32 ( - IN UINT8 *Data, - IN UINTN DataSize, - IN OUT UINT32 *CrcOut + IN UINT8 *Data, + IN UINTN DataSize, + IN OUT UINT32 *CrcOut ) ; diff --git a/BaseTools/Source/C/Common/Decompress.h b/BaseTools/Source/C/Common/Decompress.h index 00a1e31b8c21..81460cf1d6c6 100644 --- a/BaseTools/Source/C/Common/Decompress.h +++ b/BaseTools/Source/C/Common/Decompress.h @@ -127,8 +127,8 @@ EFI_STATUS Extract ( IN VOID *Source, IN UINT32 SrcSize, - OUT VOID **Destination, - OUT UINT32 *DstSize, + OUT VOID **Destination, + OUT UINT32 *DstSize, IN UINTN Algorithm ); diff --git a/BaseTools/Source/C/Common/EfiUtilityMsgs.h b/BaseTools/Source/C/Common/EfiUtilityMsgs.h index 85f018cbad1c..ffdac5bd9e14 100644 --- a/BaseTools/Source/C/Common/EfiUtilityMsgs.h +++ b/BaseTools/Source/C/Common/EfiUtilityMsgs.h @@ -14,11 +14,11 @@ SPDX-License-Identifier: BSD-2-Clause-Patent // // Log message print Level // -#define VERBOSE_LOG_LEVEL 15 -#define WARNING_LOG_LEVEL 15 -#define INFO_LOG_LEVEL 20 -#define KEY_LOG_LEVEL 40 -#define ERROR_LOG_LEVLE 50 +#define VERBOSE_LOG_LEVEL 15 +#define WARNING_LOG_LEVEL 15 +#define INFO_LOG_LEVEL 20 +#define KEY_LOG_LEVEL 40 +#define ERROR_LOG_LEVLE 50 // // Status codes returned by EFI utility programs and functions @@ -26,12 +26,12 @@ SPDX-License-Identifier: BSD-2-Clause-Patent #define STATUS_SUCCESS 0 #define STATUS_WARNING 1 #define STATUS_ERROR 2 -#define VOID void +#define VOID void typedef int STATUS; -#define MAX_LINE_LEN 0x200 -#define MAXIMUM_INPUT_FILE_NUM 10 +#define MAX_LINE_LEN 0x200 +#define MAXIMUM_INPUT_FILE_NUM 10 #ifdef __cplusplus extern "C" { @@ -53,19 +53,19 @@ GetUtilityStatus ( // VOID SetUtilityName ( - CHAR8 *ProgramName + CHAR8 *ProgramName ) ; VOID PrintMessage ( - CHAR8 *Type, - CHAR8 *FileName, - UINT32 LineNumber, - UINT32 MessageCode, - CHAR8 *Text, - CHAR8 *MsgFmt, - va_list List + CHAR8 *Type, + CHAR8 *FileName, + UINT32 LineNumber, + UINT32 MessageCode, + CHAR8 *Text, + CHAR8 *MsgFmt, + va_list List ); VOID @@ -103,19 +103,19 @@ DebugMsg ( VOID VerboseMsg ( - CHAR8 *MsgFmt, + CHAR8 *MsgFmt, ... ); VOID NormalMsg ( - CHAR8 *MsgFmt, + CHAR8 *MsgFmt, ... ); VOID KeyMsg ( - CHAR8 *MsgFmt, + CHAR8 *MsgFmt, ... ); diff --git a/BaseTools/Source/C/Common/FirmwareVolumeBufferLib.h b/BaseTools/Source/C/Common/FirmwareVolumeBufferLib.h index 6b1caba993dc..c725a6c4145d 100644 --- a/BaseTools/Source/C/Common/FirmwareVolumeBufferLib.h +++ b/BaseTools/Source/C/Common/FirmwareVolumeBufferLib.h @@ -15,149 +15,148 @@ SPDX-License-Identifier: BSD-2-Clause-Patent EFI_STATUS FvBufAddFile ( - IN OUT VOID *Fv, - IN VOID *File + IN OUT VOID *Fv, + IN VOID *File ); EFI_STATUS FvBufAddFileWithExtend ( - IN OUT VOID **Fv, - IN VOID *File + IN OUT VOID **Fv, + IN VOID *File ); EFI_STATUS FvBufAddVtfFile ( - IN OUT VOID *Fv, - IN VOID *File + IN OUT VOID *Fv, + IN VOID *File ); EFI_STATUS FvBufChecksumFile ( - IN OUT VOID *FfsFile + IN OUT VOID *FfsFile ); EFI_STATUS FvBufChecksumHeader ( - IN OUT VOID *Fv + IN OUT VOID *Fv ); EFI_STATUS FvBufClearAllFiles ( - IN OUT VOID *Fv + IN OUT VOID *Fv ); VOID FvBufCompact3ByteSize ( - OUT VOID* SizeDest, - IN UINT32 Size + OUT VOID *SizeDest, + IN UINT32 Size ); EFI_STATUS FvBufCountSections ( - IN VOID* FfsFile, - IN UINTN* Count + IN VOID *FfsFile, + IN UINTN *Count ); EFI_STATUS FvBufDuplicate ( - IN VOID *SourceFv, - IN OUT VOID **DestinationFv + IN VOID *SourceFv, + IN OUT VOID **DestinationFv ); UINT32 FvBufExpand3ByteSize ( - IN VOID* Size + IN VOID *Size ); UINT32 FvBufGetFfsFileSize ( - IN EFI_FFS_FILE_HEADER *Ffs + IN EFI_FFS_FILE_HEADER *Ffs ); UINT32 FvBufGetFfsHeaderSize ( - IN EFI_FFS_FILE_HEADER *Ffs + IN EFI_FFS_FILE_HEADER *Ffs ); EFI_STATUS FvBufExtend ( - IN VOID **Fv, - IN UINTN Size + IN VOID **Fv, + IN UINTN Size ); EFI_STATUS FvBufFindFileByName ( - IN VOID *Fv, - IN EFI_GUID *Name, - OUT VOID **File + IN VOID *Fv, + IN EFI_GUID *Name, + OUT VOID **File ); EFI_STATUS FvBufFindFileByType ( - IN VOID *Fv, - IN EFI_FV_FILETYPE Type, - OUT VOID **File + IN VOID *Fv, + IN EFI_FV_FILETYPE Type, + OUT VOID **File ); EFI_STATUS FvBufFindNextFile ( - IN VOID *Fv, - IN OUT UINTN *Key, - OUT VOID **File + IN VOID *Fv, + IN OUT UINTN *Key, + OUT VOID **File ); EFI_STATUS FvBufFindNextSection ( - IN VOID *SectionsStart, - IN UINTN TotalSectionsSize, - IN OUT UINTN *Key, - OUT VOID **Section + IN VOID *SectionsStart, + IN UINTN TotalSectionsSize, + IN OUT UINTN *Key, + OUT VOID **Section ); EFI_STATUS FvBufFindSectionByType ( - IN VOID *FfsFile, - IN UINT8 Type, - OUT VOID **Section + IN VOID *FfsFile, + IN UINT8 Type, + OUT VOID **Section ); EFI_STATUS FvBufGetFileRawData ( - IN VOID* FfsFile, - OUT VOID** RawData, - OUT UINTN* RawDataSize + IN VOID *FfsFile, + OUT VOID **RawData, + OUT UINTN *RawDataSize ); EFI_STATUS FvBufGetSize ( - IN VOID *Fv, - OUT UINTN *Size + IN VOID *Fv, + OUT UINTN *Size ); EFI_STATUS FvBufPackageFreeformRawFile ( - IN EFI_GUID* Filename, - IN VOID* RawData, - IN UINTN RawDataSize, - OUT VOID** FfsFile + IN EFI_GUID *Filename, + IN VOID *RawData, + IN UINTN RawDataSize, + OUT VOID **FfsFile ); EFI_STATUS FvBufRemoveFile ( - IN OUT VOID *Fv, - IN EFI_GUID *Name + IN OUT VOID *Fv, + IN EFI_GUID *Name ); EFI_STATUS FvBufUnifyBlockSizes ( - IN OUT VOID *Fv, - IN UINTN BlockSize + IN OUT VOID *Fv, + IN UINTN BlockSize ); EFI_STATUS FvBufShrinkWrap ( - IN VOID *Fv + IN VOID *Fv ); #endif // #ifndef FirmwareVolumeBuffer_h_INCLUDED - diff --git a/BaseTools/Source/C/Common/FvLib.h b/BaseTools/Source/C/Common/FvLib.h index 815df6f802c4..f27888a14da0 100644 --- a/BaseTools/Source/C/Common/FvLib.h +++ b/BaseTools/Source/C/Common/FvLib.h @@ -20,8 +20,8 @@ SPDX-License-Identifier: BSD-2-Clause-Patent EFI_STATUS InitializeFvLib ( - IN VOID *Fv, - IN UINT32 FvLength + IN VOID *Fv, + IN UINT32 FvLength ) ; @@ -34,71 +34,72 @@ GetFvHeader ( EFI_STATUS GetNextFile ( - IN EFI_FFS_FILE_HEADER *CurrentFile, - OUT EFI_FFS_FILE_HEADER **NextFile + IN EFI_FFS_FILE_HEADER *CurrentFile, + OUT EFI_FFS_FILE_HEADER **NextFile ) ; EFI_STATUS GetFileByName ( - IN EFI_GUID *FileName, - OUT EFI_FFS_FILE_HEADER **File + IN EFI_GUID *FileName, + OUT EFI_FFS_FILE_HEADER **File ) ; EFI_STATUS GetFileByType ( - IN EFI_FV_FILETYPE FileType, - IN UINTN Instance, - OUT EFI_FFS_FILE_HEADER **File + IN EFI_FV_FILETYPE FileType, + IN UINTN Instance, + OUT EFI_FFS_FILE_HEADER **File ) ; EFI_STATUS GetSectionByType ( - IN EFI_FFS_FILE_HEADER *File, - IN EFI_SECTION_TYPE SectionType, - IN UINTN Instance, - OUT EFI_FILE_SECTION_POINTER *Section + IN EFI_FFS_FILE_HEADER *File, + IN EFI_SECTION_TYPE SectionType, + IN UINTN Instance, + OUT EFI_FILE_SECTION_POINTER *Section ) ; + // // will not parse compressed sections // EFI_STATUS VerifyFv ( - IN EFI_FIRMWARE_VOLUME_HEADER *FvHeader + IN EFI_FIRMWARE_VOLUME_HEADER *FvHeader ) ; EFI_STATUS VerifyFfsFile ( - IN EFI_FFS_FILE_HEADER *FfsHeader + IN EFI_FFS_FILE_HEADER *FfsHeader ) ; UINT32 GetFfsFileLength ( - EFI_FFS_FILE_HEADER *FfsHeader + EFI_FFS_FILE_HEADER *FfsHeader ) ; UINT32 GetSectionFileLength ( - EFI_COMMON_SECTION_HEADER *SectionHeader + EFI_COMMON_SECTION_HEADER *SectionHeader ) ; UINT32 -GetFfsHeaderLength( - IN EFI_FFS_FILE_HEADER *FfsHeader - ) +GetFfsHeaderLength ( + IN EFI_FFS_FILE_HEADER *FfsHeader + ) ; UINT32 -GetSectionHeaderLength( - IN EFI_COMMON_SECTION_HEADER *SectionHeader - ) +GetSectionHeaderLength ( + IN EFI_COMMON_SECTION_HEADER *SectionHeader + ) ; /*++ @@ -120,7 +121,7 @@ Routine Description: --*/ UINT32 GetLength ( - UINT8 *ThreeByteLength + UINT8 *ThreeByteLength ) ; @@ -141,7 +142,7 @@ Routine Description: --*/ EFI_STATUS GetErasePolarity ( - OUT BOOLEAN *ErasePolarity + OUT BOOLEAN *ErasePolarity ) ; diff --git a/BaseTools/Source/C/Common/MemoryFile.h b/BaseTools/Source/C/Common/MemoryFile.h index c84848cf15d6..309aa57ed000 100644 --- a/BaseTools/Source/C/Common/MemoryFile.h +++ b/BaseTools/Source/C/Common/MemoryFile.h @@ -17,12 +17,11 @@ SPDX-License-Identifier: BSD-2-Clause-Patent // Common data structures // typedef struct { - CHAR8 *FileImage; - CHAR8 *Eof; - CHAR8 *CurrentFilePointer; + CHAR8 *FileImage; + CHAR8 *Eof; + CHAR8 *CurrentFilePointer; } MEMORY_FILE; - // // Functions declarations // @@ -39,8 +38,8 @@ typedef struct { **/ EFI_STATUS GetMemoryFile ( - IN CHAR8 *InputFileName, - OUT EFI_HANDLE *OutputMemoryFile + IN CHAR8 *InputFileName, + OUT EFI_HANDLE *OutputMemoryFile ) ; @@ -53,7 +52,7 @@ GetMemoryFile ( **/ EFI_STATUS FreeMemoryFile ( - IN EFI_HANDLE InputMemoryFile + IN EFI_HANDLE InputMemoryFile ) ; @@ -71,9 +70,8 @@ FreeMemoryFile ( **/ CHAR8 * ReadMemoryFileLine ( - IN EFI_HANDLE InputMemoryFile + IN EFI_HANDLE InputMemoryFile ) ; - #endif diff --git a/BaseTools/Source/C/Common/MyAlloc.h b/BaseTools/Source/C/Common/MyAlloc.h index de3323d30d97..3bdaeb63d485 100644 --- a/BaseTools/Source/C/Common/MyAlloc.h +++ b/BaseTools/Source/C/Common/MyAlloc.h @@ -22,29 +22,29 @@ SPDX-License-Identifier: BSD-2-Clause-Patent // your project. // #ifndef USE_MYALLOC -#define USE_MYALLOC 1 +#define USE_MYALLOC 1 #endif #if USE_MYALLOC // // Replace C library allocation routines with MyAlloc routines. // -#define malloc(size) MyAlloc ((size), __FILE__, __LINE__) -#define calloc(count, size) MyAlloc ((count) * (size), __FILE__, __LINE__) -#define realloc(ptr, size) MyRealloc ((ptr), (size), __FILE__, __LINE__) -#define free(ptr) MyFree ((ptr), __FILE__, __LINE__) -#define alloc_check(final) MyCheck ((final), __FILE__, __LINE__) +#define malloc(size) MyAlloc ((size), __FILE__, __LINE__) +#define calloc(count, size) MyAlloc ((count) * (size), __FILE__, __LINE__) +#define realloc(ptr, size) MyRealloc ((ptr), (size), __FILE__, __LINE__) +#define free(ptr) MyFree ((ptr), __FILE__, __LINE__) +#define alloc_check(final) MyCheck ((final), __FILE__, __LINE__) // // Structure for checking/tracking memory allocations. // typedef struct MyAllocStruct { - UINTN Cksum; - struct MyAllocStruct *Next; - UINTN Line; - UINTN Size; - UINT8 *File; - UINT8 *Buffer; + UINTN Cksum; + struct MyAllocStruct *Next; + UINTN Line; + UINTN Size; + UINT8 *File; + UINT8 *Buffer; } MY_ALLOC_STRUCT; // // Cksum := (UINTN)This + (UINTN)Next + Line + Size + (UINTN)File + @@ -84,9 +84,9 @@ typedef struct MyAllocStruct { **/ VOID MyCheck ( - BOOLEAN Final, - UINT8 File[], - UINTN Line + BOOLEAN Final, + UINT8 File[], + UINTN Line ) ; @@ -105,9 +105,9 @@ MyCheck ( **/ VOID * MyAlloc ( - UINTN Size, - UINT8 File[], - UINTN Line + UINTN Size, + UINT8 File[], + UINTN Line ) ; @@ -126,10 +126,10 @@ MyAlloc ( **/ VOID * MyRealloc ( - VOID *Ptr, - UINTN Size, - UINT8 File[], - UINTN Line + VOID *Ptr, + UINTN Size, + UINT8 File[], + UINTN Line ) ; @@ -144,9 +144,9 @@ MyRealloc ( **/ VOID MyFree ( - VOID *Ptr, - UINT8 File[], - UINTN Line + VOID *Ptr, + UINT8 File[], + UINTN Line ) ; diff --git a/BaseTools/Source/C/Common/OsPath.h b/BaseTools/Source/C/Common/OsPath.h index b1881c4a1ec7..c776901280ac 100644 --- a/BaseTools/Source/C/Common/OsPath.h +++ b/BaseTools/Source/C/Common/OsPath.h @@ -33,9 +33,9 @@ SPDX-License-Identifier: BSD-2-Clause-Patent @return NULL if error **/ -CHAR8* +CHAR8 * OsPathDirName ( - IN CHAR8 *FilePath + IN CHAR8 *FilePath ) ; @@ -54,7 +54,7 @@ OsPathDirName ( **/ VOID OsPathNormPathInPlace ( - IN CHAR8 *Path + IN CHAR8 *Path ) ; @@ -73,10 +73,10 @@ OsPathNormPathInPlace ( @return A CHAR8* string, which must be freed by the caller **/ -CHAR8* +CHAR8 * OsPathPeerFilePath ( - IN CHAR8 *OldPath, - IN CHAR8 *Peer + IN CHAR8 *OldPath, + IN CHAR8 *Peer ) ; @@ -90,7 +90,7 @@ OsPathPeerFilePath ( **/ BOOLEAN OsPathExists ( - IN CHAR8 *InputFileName + IN CHAR8 *InputFileName ) ; diff --git a/BaseTools/Source/C/Common/ParseGuidedSectionTools.h b/BaseTools/Source/C/Common/ParseGuidedSectionTools.h index 2180bbd0740f..22fa5948fee4 100644 --- a/BaseTools/Source/C/Common/ParseGuidedSectionTools.h +++ b/BaseTools/Source/C/Common/ParseGuidedSectionTools.h @@ -29,7 +29,7 @@ SPDX-License-Identifier: BSD-2-Clause-Patent **/ EFI_HANDLE ParseGuidedSectionToolsFile ( - IN CHAR8 *InputFile + IN CHAR8 *InputFile ) ; @@ -47,7 +47,7 @@ ParseGuidedSectionToolsFile ( **/ EFI_HANDLE ParseGuidedSectionToolsMemoryFile ( - IN EFI_HANDLE InputFile + IN EFI_HANDLE InputFile ) ; @@ -62,10 +62,10 @@ ParseGuidedSectionToolsMemoryFile ( @retval Non-NULL The tool to use to access the section contents. (The caller must free the memory associated with this string.) **/ -CHAR8* +CHAR8 * LookupGuidedSectionToolPath ( - IN EFI_HANDLE ParsedGuidedSectionToolsHandle, - IN EFI_GUID *SectionGuid + IN EFI_HANDLE ParsedGuidedSectionToolsHandle, + IN EFI_GUID *SectionGuid ) ; @@ -80,7 +80,7 @@ LookupGuidedSectionToolPath ( **/ EFI_STATUS FreeParsedGuidedSectionToolsHandle ( - IN EFI_HANDLE ParsedGuidedSectionToolsHandle + IN EFI_HANDLE ParsedGuidedSectionToolsHandle ) ; diff --git a/BaseTools/Source/C/Common/ParseInf.h b/BaseTools/Source/C/Common/ParseInf.h index a0881a5c9ed0..aa612f6fb730 100644 --- a/BaseTools/Source/C/Common/ParseInf.h +++ b/BaseTools/Source/C/Common/ParseInf.h @@ -38,9 +38,9 @@ extern "C" { **/ CHAR8 * ReadLine ( - IN MEMORY_FILE *InputFile, - IN OUT CHAR8 *InputBuffer, - IN UINTN MaxLength + IN MEMORY_FILE *InputFile, + IN OUT CHAR8 *InputBuffer, + IN UINTN MaxLength ) ; @@ -56,8 +56,8 @@ ReadLine ( **/ BOOLEAN FindSection ( - IN MEMORY_FILE *InputFile, - IN CHAR8 *Section + IN MEMORY_FILE *InputFile, + IN CHAR8 *Section ) ; @@ -78,11 +78,11 @@ FindSection ( **/ EFI_STATUS FindToken ( - IN MEMORY_FILE *InputFile, - IN CHAR8 *Section, - IN CHAR8 *Token, - IN UINTN Instance, - OUT CHAR8 *Value + IN MEMORY_FILE *InputFile, + IN CHAR8 *Section, + IN CHAR8 *Token, + IN UINTN Instance, + OUT CHAR8 *Value ) ; @@ -98,8 +98,8 @@ FindToken ( **/ EFI_STATUS StringToGuid ( - IN CHAR8 *AsciiGuidBuffer, - OUT EFI_GUID *GuidBuffer + IN CHAR8 *AsciiGuidBuffer, + OUT EFI_GUID *GuidBuffer ) ; @@ -152,8 +152,8 @@ ReadLineInStream ( **/ BOOLEAN FindSectionInStream ( - IN FILE *InputFile, - IN CHAR8 *Section + IN FILE *InputFile, + IN CHAR8 *Section ) ; diff --git a/BaseTools/Source/C/Common/PcdValueCommon.h b/BaseTools/Source/C/Common/PcdValueCommon.h index 7dac5bd92dbc..3f4d35cf8f71 100644 --- a/BaseTools/Source/C/Common/PcdValueCommon.h +++ b/BaseTools/Source/C/Common/PcdValueCommon.h @@ -12,16 +12,16 @@ SPDX-License-Identifier: BSD-2-Clause-Patent #include #include -#define __FIELD_SIZE(TYPE, Field) (sizeof((TYPE *)0)->Field) -#define __ARRAY_ELEMENT_SIZE(TYPE, Field) (sizeof((TYPE *)0)->Field[0]) -#define __OFFSET_OF(TYPE, Field) ((UINT32)(size_t) &(((TYPE *)0)->Field)) -#define __FLEXIBLE_SIZE(Size, TYPE, Field, MaxIndex) if (__FIELD_SIZE(TYPE, Field) == 0) Size = MAX((__OFFSET_OF(TYPE, Field) + __ARRAY_ELEMENT_SIZE(TYPE, Field) * (MaxIndex)), Size) -#define __ARRAY_SIZE(Array) (sizeof(Array)/sizeof(Array[0])) +#define __FIELD_SIZE(TYPE, Field) (sizeof((TYPE *)0)->Field) +#define __ARRAY_ELEMENT_SIZE(TYPE, Field) (sizeof((TYPE *)0)->Field[0]) +#define __OFFSET_OF(TYPE, Field) ((UINT32)(size_t) &(((TYPE *)0)->Field)) +#define __FLEXIBLE_SIZE(Size, TYPE, Field, MaxIndex) if (__FIELD_SIZE(TYPE, Field) == 0) Size = MAX((__OFFSET_OF(TYPE, Field) + __ARRAY_ELEMENT_SIZE(TYPE, Field) * (MaxIndex)), Size) +#define __ARRAY_SIZE(Array) (sizeof(Array)/sizeof(Array[0])) -#if defined(_MSC_EXTENSIONS) -#define __STATIC_ASSERT static_assert +#if defined (_MSC_EXTENSIONS) +#define __STATIC_ASSERT static_assert #else -#define __STATIC_ASSERT _Static_assert +#define __STATIC_ASSERT _Static_assert #endif /** @@ -129,9 +129,9 @@ __PcdSetPtr ( ) ; -#define PcdGet(A, B, C, D) __PcdGet(#A, #B, #C, #D) -#define PcdSet(A, B, C, D, Value) __PcdSet(#A, #B, #C, #D, Value) -#define PcdGetPtr(A, B, C, D, Size) __PcdGetPtr(#A, #B, #C, #D, Size) +#define PcdGet(A, B, C, D) __PcdGet(#A, #B, #C, #D) +#define PcdSet(A, B, C, D, Value) __PcdSet(#A, #B, #C, #D, Value) +#define PcdGetPtr(A, B, C, D, Size) __PcdGetPtr(#A, #B, #C, #D, Size) #define PcdSetPtr(A, B, C, D, Size, Value) __PcdSetPtr(#A, #B, #C, #D, Size, Value) #endif diff --git a/BaseTools/Source/C/Common/PeCoffLib.h b/BaseTools/Source/C/Common/PeCoffLib.h index dd38f442f952..0da434fc19f6 100644 --- a/BaseTools/Source/C/Common/PeCoffLib.h +++ b/BaseTools/Source/C/Common/PeCoffLib.h @@ -29,9 +29,9 @@ // // Macro definitions for RISC-V architecture. // -#define RV_X(x, s, n) (((x) >> (s)) & ((1<<(n))-1)) -#define RISCV_IMM_BITS 12 -#define RISCV_IMM_REACH (1LL<> (s)) & ((1<<(n))-1)) +#define RISCV_IMM_BITS 12 +#define RISCV_IMM_REACH (1LL<ImageRead ( - ImageContext->Handle, - 0, - &Size, - &DosHdr - ); + ImageContext->Handle, + 0, + &Size, + &DosHdr + ); if (RETURN_ERROR (Status)) { ImageContext->ImageError = IMAGE_ERROR_IMAGE_READ; return Status; @@ -122,10 +121,11 @@ PeCoffLoaderGetPeHeader ( // ImageContext->PeCoffHeaderOffset = DosHdr.e_lfanew; } + // // Get the PE/COFF Header pointer // - *PeHdr = (EFI_IMAGE_OPTIONAL_HEADER_UNION *) ((UINTN)ImageContext->Handle + ImageContext->PeCoffHeaderOffset); + *PeHdr = (EFI_IMAGE_OPTIONAL_HEADER_UNION *)((UINTN)ImageContext->Handle + ImageContext->PeCoffHeaderOffset); if ((*PeHdr)->Pe32.Signature != EFI_IMAGE_NT_SIGNATURE) { // // Check the PE/COFF Header Signature. If not, then try to get a TE header @@ -134,6 +134,7 @@ PeCoffLoaderGetPeHeader ( if ((*TeHdr)->Signature != EFI_TE_IMAGE_HEADER_SIGNATURE) { return RETURN_UNSUPPORTED; } + ImageContext->IsTeImage = TRUE; } @@ -154,9 +155,9 @@ PeCoffLoaderGetPeHeader ( STATIC RETURN_STATUS PeCoffLoaderCheckImageType ( - IN OUT PE_COFF_LOADER_IMAGE_CONTEXT *ImageContext, - IN EFI_IMAGE_OPTIONAL_HEADER_UNION *PeHdr, - IN EFI_TE_IMAGE_HEADER *TeHdr + IN OUT PE_COFF_LOADER_IMAGE_CONTEXT *ImageContext, + IN EFI_IMAGE_OPTIONAL_HEADER_UNION *PeHdr, + IN EFI_TE_IMAGE_HEADER *TeHdr ) { // @@ -169,13 +170,14 @@ PeCoffLoaderCheckImageType ( ImageContext->Machine = TeHdr->Machine; } - if (ImageContext->Machine != EFI_IMAGE_MACHINE_IA32 && \ - ImageContext->Machine != EFI_IMAGE_MACHINE_X64 && \ - ImageContext->Machine != EFI_IMAGE_MACHINE_ARMT && \ - ImageContext->Machine != EFI_IMAGE_MACHINE_EBC && \ - ImageContext->Machine != EFI_IMAGE_MACHINE_AARCH64 && \ - ImageContext->Machine != EFI_IMAGE_MACHINE_RISCV64 && \ - ImageContext->Machine != EFI_IMAGE_MACHINE_LOONGARCH64) { + if ((ImageContext->Machine != EFI_IMAGE_MACHINE_IA32) && \ + (ImageContext->Machine != EFI_IMAGE_MACHINE_X64) && \ + (ImageContext->Machine != EFI_IMAGE_MACHINE_ARMT) && \ + (ImageContext->Machine != EFI_IMAGE_MACHINE_EBC) && \ + (ImageContext->Machine != EFI_IMAGE_MACHINE_AARCH64) && \ + (ImageContext->Machine != EFI_IMAGE_MACHINE_RISCV64) && \ + (ImageContext->Machine != EFI_IMAGE_MACHINE_LOONGARCH64)) + { if (ImageContext->Machine == IMAGE_FILE_MACHINE_ARM) { // // There are two types of ARM images. Pure ARM and ARM/Thumb. @@ -188,7 +190,6 @@ PeCoffLoaderCheckImageType ( } else { TeHdr->Machine = ImageContext->Machine; } - } else { // // unsupported PeImage machine type @@ -204,13 +205,14 @@ PeCoffLoaderCheckImageType ( if (ImageContext->IsTeImage == FALSE) { ImageContext->ImageType = PeHdr->Pe32.OptionalHeader.Subsystem; } else { - ImageContext->ImageType = (UINT16) (TeHdr->Subsystem); + ImageContext->ImageType = (UINT16)(TeHdr->Subsystem); } - if (ImageContext->ImageType != EFI_IMAGE_SUBSYSTEM_EFI_APPLICATION && \ - ImageContext->ImageType != EFI_IMAGE_SUBSYSTEM_EFI_BOOT_SERVICE_DRIVER && \ - ImageContext->ImageType != EFI_IMAGE_SUBSYSTEM_EFI_RUNTIME_DRIVER && \ - ImageContext->ImageType != EFI_IMAGE_SUBSYSTEM_SAL_RUNTIME_DRIVER) { + if ((ImageContext->ImageType != EFI_IMAGE_SUBSYSTEM_EFI_APPLICATION) && \ + (ImageContext->ImageType != EFI_IMAGE_SUBSYSTEM_EFI_BOOT_SERVICE_DRIVER) && \ + (ImageContext->ImageType != EFI_IMAGE_SUBSYSTEM_EFI_RUNTIME_DRIVER) && \ + (ImageContext->ImageType != EFI_IMAGE_SUBSYSTEM_SAL_RUNTIME_DRIVER)) + { // // unsupported PeImage subsystem type // @@ -236,36 +238,37 @@ PeCoffLoaderCheckImageType ( RETURN_STATUS EFIAPI PeCoffLoaderGetImageInfo ( - IN OUT PE_COFF_LOADER_IMAGE_CONTEXT *ImageContext + IN OUT PE_COFF_LOADER_IMAGE_CONTEXT *ImageContext ) { - RETURN_STATUS Status; - EFI_IMAGE_OPTIONAL_HEADER_UNION *PeHdr; - EFI_TE_IMAGE_HEADER *TeHdr; - EFI_IMAGE_DATA_DIRECTORY *DebugDirectoryEntry; - UINTN Size; - UINTN Index; - UINTN DebugDirectoryEntryRva; - UINTN DebugDirectoryEntryFileOffset; - UINTN SectionHeaderOffset; - EFI_IMAGE_SECTION_HEADER SectionHeader; - EFI_IMAGE_DEBUG_DIRECTORY_ENTRY DebugEntry; - EFI_IMAGE_OPTIONAL_HEADER_POINTER OptionHeader; + RETURN_STATUS Status; + EFI_IMAGE_OPTIONAL_HEADER_UNION *PeHdr; + EFI_TE_IMAGE_HEADER *TeHdr; + EFI_IMAGE_DATA_DIRECTORY *DebugDirectoryEntry; + UINTN Size; + UINTN Index; + UINTN DebugDirectoryEntryRva; + UINTN DebugDirectoryEntryFileOffset; + UINTN SectionHeaderOffset; + EFI_IMAGE_SECTION_HEADER SectionHeader; + EFI_IMAGE_DEBUG_DIRECTORY_ENTRY DebugEntry; + EFI_IMAGE_OPTIONAL_HEADER_POINTER OptionHeader; - PeHdr = NULL; - TeHdr = NULL; + PeHdr = NULL; + TeHdr = NULL; DebugDirectoryEntry = NULL; DebugDirectoryEntryRva = 0; if (NULL == ImageContext) { return RETURN_INVALID_PARAMETER; } + // // Assume success // - ImageContext->ImageError = IMAGE_ERROR_SUCCESS; + ImageContext->ImageError = IMAGE_ERROR_SUCCESS; - Status = PeCoffLoaderGetPeHeader (ImageContext, &PeHdr, &TeHdr); + Status = PeCoffLoaderGetPeHeader (ImageContext, &PeHdr, &TeHdr); if (RETURN_ERROR (Status)) { return Status; } @@ -277,20 +280,22 @@ PeCoffLoaderGetImageInfo ( if (RETURN_ERROR (Status)) { return Status; } - OptionHeader.Header = (VOID *) &(PeHdr->Pe32.OptionalHeader); + + OptionHeader.Header = (VOID *)&(PeHdr->Pe32.OptionalHeader); // // Retrieve the base address of the image // if (!(ImageContext->IsTeImage)) { if (PeHdr->Pe32.OptionalHeader.Magic == EFI_IMAGE_NT_OPTIONAL_HDR32_MAGIC) { - ImageContext->ImageAddress = (PHYSICAL_ADDRESS) OptionHeader.Optional32->ImageBase; + ImageContext->ImageAddress = (PHYSICAL_ADDRESS)OptionHeader.Optional32->ImageBase; } else { - ImageContext->ImageAddress = (PHYSICAL_ADDRESS) OptionHeader.Optional64->ImageBase; + ImageContext->ImageAddress = (PHYSICAL_ADDRESS)OptionHeader.Optional64->ImageBase; } } else { - ImageContext->ImageAddress = (PHYSICAL_ADDRESS) (TeHdr->ImageBase + TeHdr->StrippedSize - sizeof (EFI_TE_IMAGE_HEADER)); + ImageContext->ImageAddress = (PHYSICAL_ADDRESS)(TeHdr->ImageBase + TeHdr->StrippedSize - sizeof (EFI_TE_IMAGE_HEADER)); } + // // Initialize the alternate destination address to 0 indicating that it // should not be used. @@ -300,8 +305,8 @@ PeCoffLoaderGetImageInfo ( // // Initialize the codeview pointer. // - ImageContext->CodeView = NULL; - ImageContext->PdbPointer = NULL; + ImageContext->CodeView = NULL; + ImageContext->PdbPointer = NULL; // // Three cases with regards to relocations: @@ -323,31 +328,30 @@ PeCoffLoaderGetImageInfo ( } if (!(ImageContext->IsTeImage)) { - if (PeHdr->Pe32.OptionalHeader.Magic == EFI_IMAGE_NT_OPTIONAL_HDR32_MAGIC) { - ImageContext->ImageSize = (UINT64) OptionHeader.Optional32->SizeOfImage; - ImageContext->SectionAlignment = OptionHeader.Optional32->SectionAlignment; - ImageContext->SizeOfHeaders = OptionHeader.Optional32->SizeOfHeaders; + ImageContext->ImageSize = (UINT64)OptionHeader.Optional32->SizeOfImage; + ImageContext->SectionAlignment = OptionHeader.Optional32->SectionAlignment; + ImageContext->SizeOfHeaders = OptionHeader.Optional32->SizeOfHeaders; // // Modify ImageSize to contain .PDB file name if required and initialize // PdbRVA field... // if (OptionHeader.Optional32->NumberOfRvaAndSizes > EFI_IMAGE_DIRECTORY_ENTRY_DEBUG) { - DebugDirectoryEntry = (EFI_IMAGE_DATA_DIRECTORY *) &(OptionHeader.Optional32->DataDirectory[EFI_IMAGE_DIRECTORY_ENTRY_DEBUG]); + DebugDirectoryEntry = (EFI_IMAGE_DATA_DIRECTORY *)&(OptionHeader.Optional32->DataDirectory[EFI_IMAGE_DIRECTORY_ENTRY_DEBUG]); DebugDirectoryEntryRva = DebugDirectoryEntry->VirtualAddress; } } else { - ImageContext->ImageSize = (UINT64) OptionHeader.Optional64->SizeOfImage; - ImageContext->SectionAlignment = OptionHeader.Optional64->SectionAlignment; - ImageContext->SizeOfHeaders = OptionHeader.Optional64->SizeOfHeaders; + ImageContext->ImageSize = (UINT64)OptionHeader.Optional64->SizeOfImage; + ImageContext->SectionAlignment = OptionHeader.Optional64->SectionAlignment; + ImageContext->SizeOfHeaders = OptionHeader.Optional64->SizeOfHeaders; // // Modify ImageSize to contain .PDB file name if required and initialize // PdbRVA field... // if (OptionHeader.Optional64->NumberOfRvaAndSizes > EFI_IMAGE_DIRECTORY_ENTRY_DEBUG) { - DebugDirectoryEntry = (EFI_IMAGE_DATA_DIRECTORY *) &(OptionHeader.Optional64->DataDirectory[EFI_IMAGE_DIRECTORY_ENTRY_DEBUG]); + DebugDirectoryEntry = (EFI_IMAGE_DATA_DIRECTORY *)&(OptionHeader.Optional64->DataDirectory[EFI_IMAGE_DIRECTORY_ENTRY_DEBUG]); DebugDirectoryEntryRva = DebugDirectoryEntry->VirtualAddress; } } @@ -361,17 +365,17 @@ PeCoffLoaderGetImageInfo ( DebugDirectoryEntryFileOffset = 0; SectionHeaderOffset = (UINTN)( - ImageContext->PeCoffHeaderOffset + - sizeof (UINT32) + - sizeof (EFI_IMAGE_FILE_HEADER) + - PeHdr->Pe32.FileHeader.SizeOfOptionalHeader - ); + ImageContext->PeCoffHeaderOffset + + sizeof (UINT32) + + sizeof (EFI_IMAGE_FILE_HEADER) + + PeHdr->Pe32.FileHeader.SizeOfOptionalHeader + ); for (Index = 0; Index < PeHdr->Pe32.FileHeader.NumberOfSections; Index++) { // // Read section header from file // - Size = sizeof (EFI_IMAGE_SECTION_HEADER); + Size = sizeof (EFI_IMAGE_SECTION_HEADER); Status = ImageContext->ImageRead ( ImageContext->Handle, SectionHeaderOffset, @@ -383,9 +387,10 @@ PeCoffLoaderGetImageInfo ( return Status; } - if (DebugDirectoryEntryRva >= SectionHeader.VirtualAddress && - DebugDirectoryEntryRva < SectionHeader.VirtualAddress + SectionHeader.Misc.VirtualSize) { - DebugDirectoryEntryFileOffset = + if ((DebugDirectoryEntryRva >= SectionHeader.VirtualAddress) && + (DebugDirectoryEntryRva < SectionHeader.VirtualAddress + SectionHeader.Misc.VirtualSize)) + { + DebugDirectoryEntryFileOffset = DebugDirectoryEntryRva - SectionHeader.VirtualAddress + SectionHeader.PointerToRawData; break; } @@ -398,7 +403,7 @@ PeCoffLoaderGetImageInfo ( // // Read next debug directory entry // - Size = sizeof (EFI_IMAGE_DEBUG_DIRECTORY_ENTRY); + Size = sizeof (EFI_IMAGE_DEBUG_DIRECTORY_ENTRY); Status = ImageContext->ImageRead ( ImageContext->Handle, DebugDirectoryEntryFileOffset + Index, @@ -411,8 +416,8 @@ PeCoffLoaderGetImageInfo ( } if (DebugEntry.Type == EFI_IMAGE_DEBUG_TYPE_CODEVIEW) { - ImageContext->DebugDirectoryEntryRva = (UINT32) (DebugDirectoryEntryRva + Index); - if (DebugEntry.RVA == 0 && DebugEntry.FileOffset != 0) { + ImageContext->DebugDirectoryEntryRva = (UINT32)(DebugDirectoryEntryRva + Index); + if ((DebugEntry.RVA == 0) && (DebugEntry.FileOffset != 0)) { ImageContext->ImageSize += DebugEntry.SizeOfData; } @@ -422,21 +427,21 @@ PeCoffLoaderGetImageInfo ( } } } else { - ImageContext->ImageSize = 0; - ImageContext->SectionAlignment = 4096; - ImageContext->SizeOfHeaders = sizeof (EFI_TE_IMAGE_HEADER) + (UINTN) TeHdr->BaseOfCode - (UINTN) TeHdr->StrippedSize; + ImageContext->ImageSize = 0; + ImageContext->SectionAlignment = 4096; + ImageContext->SizeOfHeaders = sizeof (EFI_TE_IMAGE_HEADER) + (UINTN)TeHdr->BaseOfCode - (UINTN)TeHdr->StrippedSize; - DebugDirectoryEntry = &TeHdr->DataDirectory[1]; - DebugDirectoryEntryRva = DebugDirectoryEntry->VirtualAddress; - SectionHeaderOffset = (UINTN) (sizeof (EFI_TE_IMAGE_HEADER)); + DebugDirectoryEntry = &TeHdr->DataDirectory[1]; + DebugDirectoryEntryRva = DebugDirectoryEntry->VirtualAddress; + SectionHeaderOffset = (UINTN)(sizeof (EFI_TE_IMAGE_HEADER)); - DebugDirectoryEntryFileOffset = 0; + DebugDirectoryEntryFileOffset = 0; for (Index = 0; Index < TeHdr->NumberOfSections;) { // // Read section header from file // - Size = sizeof (EFI_IMAGE_SECTION_HEADER); + Size = sizeof (EFI_IMAGE_SECTION_HEADER); Status = ImageContext->ImageRead ( ImageContext->Handle, SectionHeaderOffset, @@ -448,21 +453,22 @@ PeCoffLoaderGetImageInfo ( return Status; } - if (DebugDirectoryEntryRva >= SectionHeader.VirtualAddress && - DebugDirectoryEntryRva < SectionHeader.VirtualAddress + SectionHeader.Misc.VirtualSize) { + if ((DebugDirectoryEntryRva >= SectionHeader.VirtualAddress) && + (DebugDirectoryEntryRva < SectionHeader.VirtualAddress + SectionHeader.Misc.VirtualSize)) + { DebugDirectoryEntryFileOffset = DebugDirectoryEntryRva - - SectionHeader.VirtualAddress + - SectionHeader.PointerToRawData + - sizeof (EFI_TE_IMAGE_HEADER) - - TeHdr->StrippedSize; + SectionHeader.VirtualAddress + + SectionHeader.PointerToRawData + + sizeof (EFI_TE_IMAGE_HEADER) - + TeHdr->StrippedSize; // // File offset of the debug directory was found, if this is not the last // section, then skip to the last section for calculating the image size. // - if (Index < (UINTN) TeHdr->NumberOfSections - 1) { + if (Index < (UINTN)TeHdr->NumberOfSections - 1) { SectionHeaderOffset += (TeHdr->NumberOfSections - 1 - Index) * sizeof (EFI_IMAGE_SECTION_HEADER); - Index = TeHdr->NumberOfSections - 1; + Index = TeHdr->NumberOfSections - 1; continue; } } @@ -477,7 +483,7 @@ PeCoffLoaderGetImageInfo ( // by the RVA and the VirtualSize of the last section header in the // Section Table. // - if ((++Index) == (UINTN) TeHdr->NumberOfSections) { + if ((++Index) == (UINTN)TeHdr->NumberOfSections) { ImageContext->ImageSize = (SectionHeader.VirtualAddress + SectionHeader.Misc.VirtualSize + ImageContext->SectionAlignment - 1) & ~(ImageContext->SectionAlignment - 1); } @@ -490,7 +496,7 @@ PeCoffLoaderGetImageInfo ( // // Read next debug directory entry // - Size = sizeof (EFI_IMAGE_DEBUG_DIRECTORY_ENTRY); + Size = sizeof (EFI_IMAGE_DEBUG_DIRECTORY_ENTRY); Status = ImageContext->ImageRead ( ImageContext->Handle, DebugDirectoryEntryFileOffset, @@ -503,7 +509,7 @@ PeCoffLoaderGetImageInfo ( } if (DebugEntry.Type == EFI_IMAGE_DEBUG_TYPE_CODEVIEW) { - ImageContext->DebugDirectoryEntryRva = (UINT32) (DebugDirectoryEntryRva + Index); + ImageContext->DebugDirectoryEntryRva = (UINT32)(DebugDirectoryEntryRva + Index); return RETURN_SUCCESS; } } @@ -525,8 +531,8 @@ PeCoffLoaderGetImageInfo ( STATIC VOID * PeCoffLoaderImageAddress ( - IN OUT PE_COFF_LOADER_IMAGE_CONTEXT *ImageContext, - IN UINTN Address + IN OUT PE_COFF_LOADER_IMAGE_CONTEXT *ImageContext, + IN UINTN Address ) { if (Address >= ImageContext->ImageSize) { @@ -534,7 +540,7 @@ PeCoffLoaderImageAddress ( return NULL; } - return (UINT8 *) ((UINTN) ImageContext->ImageAddress + Address); + return (UINT8 *)((UINTN)ImageContext->ImageAddress + Address); } /** @@ -554,24 +560,24 @@ PeCoffLoaderRelocateImage ( IN OUT PE_COFF_LOADER_IMAGE_CONTEXT *ImageContext ) { - RETURN_STATUS Status; - EFI_IMAGE_OPTIONAL_HEADER_UNION *PeHdr; - EFI_TE_IMAGE_HEADER *TeHdr; - EFI_IMAGE_DATA_DIRECTORY *RelocDir; - UINT64 Adjust; - EFI_IMAGE_BASE_RELOCATION *RelocBase; - EFI_IMAGE_BASE_RELOCATION *RelocBaseEnd; - UINT16 *Reloc; - UINT16 *RelocEnd; - CHAR8 *Fixup; - CHAR8 *FixupBase; - UINT16 *F16; - UINT32 *F32; - UINT64 *F64; - CHAR8 *FixupData; - PHYSICAL_ADDRESS BaseAddress; - UINT16 MachineType; - EFI_IMAGE_OPTIONAL_HEADER_POINTER OptionHeader; + RETURN_STATUS Status; + EFI_IMAGE_OPTIONAL_HEADER_UNION *PeHdr; + EFI_TE_IMAGE_HEADER *TeHdr; + EFI_IMAGE_DATA_DIRECTORY *RelocDir; + UINT64 Adjust; + EFI_IMAGE_BASE_RELOCATION *RelocBase; + EFI_IMAGE_BASE_RELOCATION *RelocBaseEnd; + UINT16 *Reloc; + UINT16 *RelocEnd; + CHAR8 *Fixup; + CHAR8 *FixupBase; + UINT16 *F16; + UINT32 *F32; + UINT64 *F64; + CHAR8 *FixupData; + PHYSICAL_ADDRESS BaseAddress; + UINT16 MachineType; + EFI_IMAGE_OPTIONAL_HEADER_POINTER OptionHeader; PeHdr = NULL; TeHdr = NULL; @@ -594,12 +600,12 @@ PeCoffLoaderRelocateImage ( if (!(ImageContext->IsTeImage)) { PeHdr = (EFI_IMAGE_OPTIONAL_HEADER_UNION *)((UINTN)ImageContext->ImageAddress + - ImageContext->PeCoffHeaderOffset); - OptionHeader.Header = (VOID *) &(PeHdr->Pe32.OptionalHeader); + ImageContext->PeCoffHeaderOffset); + OptionHeader.Header = (VOID *)&(PeHdr->Pe32.OptionalHeader); if (PeHdr->Pe32.OptionalHeader.Magic == EFI_IMAGE_NT_OPTIONAL_HDR32_MAGIC) { - Adjust = (UINT64) BaseAddress - OptionHeader.Optional32->ImageBase; - OptionHeader.Optional32->ImageBase = (UINT32) BaseAddress; - MachineType = ImageContext->Machine; + Adjust = (UINT64)BaseAddress - OptionHeader.Optional32->ImageBase; + OptionHeader.Optional32->ImageBase = (UINT32)BaseAddress; + MachineType = ImageContext->Machine; // // Find the relocation block // @@ -608,14 +614,14 @@ PeCoffLoaderRelocateImage ( // the optional header to verify a desired directory entry is there. // if (OptionHeader.Optional32->NumberOfRvaAndSizes > EFI_IMAGE_DIRECTORY_ENTRY_BASERELOC) { - RelocDir = &OptionHeader.Optional32->DataDirectory[EFI_IMAGE_DIRECTORY_ENTRY_BASERELOC]; + RelocDir = &OptionHeader.Optional32->DataDirectory[EFI_IMAGE_DIRECTORY_ENTRY_BASERELOC]; if ((RelocDir != NULL) && (RelocDir->Size > 0)) { - RelocBase = PeCoffLoaderImageAddress (ImageContext, RelocDir->VirtualAddress); + RelocBase = PeCoffLoaderImageAddress (ImageContext, RelocDir->VirtualAddress); RelocBaseEnd = PeCoffLoaderImageAddress ( ImageContext, RelocDir->VirtualAddress + RelocDir->Size - 1 ); - if (RelocBase == NULL || RelocBaseEnd == NULL || RelocBaseEnd < RelocBase) { + if ((RelocBase == NULL) || (RelocBaseEnd == NULL) || (RelocBaseEnd < RelocBase)) { ImageContext->ImageError = IMAGE_ERROR_FAILED_RELOCATION; return RETURN_LOAD_ERROR; } @@ -632,9 +638,9 @@ PeCoffLoaderRelocateImage ( RelocBase = RelocBaseEnd = 0; } } else { - Adjust = (UINT64) BaseAddress - OptionHeader.Optional64->ImageBase; + Adjust = (UINT64)BaseAddress - OptionHeader.Optional64->ImageBase; OptionHeader.Optional64->ImageBase = BaseAddress; - MachineType = ImageContext->Machine; + MachineType = ImageContext->Machine; // // Find the relocation block // @@ -643,14 +649,14 @@ PeCoffLoaderRelocateImage ( // the optional header to verify a desired directory entry is there. // if (OptionHeader.Optional64->NumberOfRvaAndSizes > EFI_IMAGE_DIRECTORY_ENTRY_BASERELOC) { - RelocDir = &OptionHeader.Optional64->DataDirectory[EFI_IMAGE_DIRECTORY_ENTRY_BASERELOC]; + RelocDir = &OptionHeader.Optional64->DataDirectory[EFI_IMAGE_DIRECTORY_ENTRY_BASERELOC]; if ((RelocDir != NULL) && (RelocDir->Size > 0)) { - RelocBase = PeCoffLoaderImageAddress (ImageContext, RelocDir->VirtualAddress); + RelocBase = PeCoffLoaderImageAddress (ImageContext, RelocDir->VirtualAddress); RelocBaseEnd = PeCoffLoaderImageAddress ( ImageContext, RelocDir->VirtualAddress + RelocDir->Size - 1 - ); - if (RelocBase == NULL || RelocBaseEnd == NULL || RelocBaseEnd < RelocBase) { + ); + if ((RelocBase == NULL) || (RelocBaseEnd == NULL) || (RelocBaseEnd < RelocBase)) { ImageContext->ImageError = IMAGE_ERROR_FAILED_RELOCATION; return RETURN_LOAD_ERROR; } @@ -668,22 +674,22 @@ PeCoffLoaderRelocateImage ( } } } else { - TeHdr = (EFI_TE_IMAGE_HEADER *) (UINTN) (ImageContext->ImageAddress); - Adjust = (UINT64) (BaseAddress - TeHdr->ImageBase); - TeHdr->ImageBase = (UINT64) (BaseAddress); - MachineType = TeHdr->Machine; + TeHdr = (EFI_TE_IMAGE_HEADER *)(UINTN)(ImageContext->ImageAddress); + Adjust = (UINT64)(BaseAddress - TeHdr->ImageBase); + TeHdr->ImageBase = (UINT64)(BaseAddress); + MachineType = TeHdr->Machine; // // Find the relocation block // - RelocDir = &TeHdr->DataDirectory[0]; + RelocDir = &TeHdr->DataDirectory[0]; RelocBase = (EFI_IMAGE_BASE_RELOCATION *)(UINTN)( - ImageContext->ImageAddress + - RelocDir->VirtualAddress + - sizeof(EFI_TE_IMAGE_HEADER) - - TeHdr->StrippedSize - ); - RelocBaseEnd = (EFI_IMAGE_BASE_RELOCATION *) ((UINTN) RelocBase + (UINTN) RelocDir->Size - 1); + ImageContext->ImageAddress + + RelocDir->VirtualAddress + + sizeof (EFI_TE_IMAGE_HEADER) - + TeHdr->StrippedSize + ); + RelocBaseEnd = (EFI_IMAGE_BASE_RELOCATION *)((UINTN)RelocBase + (UINTN)RelocDir->Size - 1); } // @@ -691,9 +697,8 @@ PeCoffLoaderRelocateImage ( // FixupData = ImageContext->FixupData; while (RelocBase < RelocBaseEnd) { - - Reloc = (UINT16 *) ((CHAR8 *) RelocBase + sizeof (EFI_IMAGE_BASE_RELOCATION)); - RelocEnd = (UINT16 *) ((CHAR8 *) RelocBase + RelocBase->SizeOfBlock); + Reloc = (UINT16 *)((CHAR8 *)RelocBase + sizeof (EFI_IMAGE_BASE_RELOCATION)); + RelocEnd = (UINT16 *)((CHAR8 *)RelocBase + RelocBase->SizeOfBlock); if (!(ImageContext->IsTeImage)) { FixupBase = PeCoffLoaderImageAddress (ImageContext, RelocBase->VirtualAddress); if (FixupBase == NULL) { @@ -702,15 +707,16 @@ PeCoffLoaderRelocateImage ( } } else { FixupBase = (CHAR8 *)(UINTN)(ImageContext->ImageAddress + - RelocBase->VirtualAddress + - sizeof(EFI_TE_IMAGE_HEADER) - - TeHdr->StrippedSize - ); + RelocBase->VirtualAddress + + sizeof (EFI_TE_IMAGE_HEADER) - + TeHdr->StrippedSize + ); } - if ((CHAR8 *) RelocEnd < (CHAR8 *) ((UINTN) ImageContext->ImageAddress) || - (CHAR8 *) RelocEnd > (CHAR8 *)((UINTN)ImageContext->ImageAddress + - (UINTN)ImageContext->ImageSize)) { + if (((CHAR8 *)RelocEnd < (CHAR8 *)((UINTN)ImageContext->ImageAddress)) || + ((CHAR8 *)RelocEnd > (CHAR8 *)((UINTN)ImageContext->ImageAddress + + (UINTN)ImageContext->ImageSize))) + { ImageContext->ImageError = IMAGE_ERROR_FAILED_RELOCATION; return RETURN_LOAD_ERROR; } @@ -719,81 +725,85 @@ PeCoffLoaderRelocateImage ( // Run this relocation record // while (Reloc < RelocEnd) { - Fixup = FixupBase + (*Reloc & 0xFFF); switch ((*Reloc) >> 12) { - case EFI_IMAGE_REL_BASED_ABSOLUTE: - break; + case EFI_IMAGE_REL_BASED_ABSOLUTE: + break; - case EFI_IMAGE_REL_BASED_HIGH: - F16 = (UINT16 *) Fixup; - *F16 = (UINT16) (*F16 + ((UINT16) ((UINT32) Adjust >> 16))); - if (FixupData != NULL) { - *(UINT16 *) FixupData = *F16; - FixupData = FixupData + sizeof (UINT16); - } - break; + case EFI_IMAGE_REL_BASED_HIGH: + F16 = (UINT16 *)Fixup; + *F16 = (UINT16)(*F16 + ((UINT16)((UINT32)Adjust >> 16))); + if (FixupData != NULL) { + *(UINT16 *)FixupData = *F16; + FixupData = FixupData + sizeof (UINT16); + } - case EFI_IMAGE_REL_BASED_LOW: - F16 = (UINT16 *) Fixup; - *F16 = (UINT16) (*F16 + (UINT16) Adjust); - if (FixupData != NULL) { - *(UINT16 *) FixupData = *F16; - FixupData = FixupData + sizeof (UINT16); - } - break; + break; - case EFI_IMAGE_REL_BASED_HIGHLOW: - F32 = (UINT32 *) Fixup; - *F32 = *F32 + (UINT32) Adjust; - if (FixupData != NULL) { - FixupData = ALIGN_POINTER (FixupData, sizeof (UINT32)); - *(UINT32 *) FixupData = *F32; - FixupData = FixupData + sizeof (UINT32); - } - break; + case EFI_IMAGE_REL_BASED_LOW: + F16 = (UINT16 *)Fixup; + *F16 = (UINT16)(*F16 + (UINT16)Adjust); + if (FixupData != NULL) { + *(UINT16 *)FixupData = *F16; + FixupData = FixupData + sizeof (UINT16); + } - case EFI_IMAGE_REL_BASED_DIR64: - F64 = (UINT64 *) Fixup; - *F64 = *F64 + (UINT64) Adjust; - if (FixupData != NULL) { - FixupData = ALIGN_POINTER (FixupData, sizeof (UINT64)); - *(UINT64 *) FixupData = *F64; - FixupData = FixupData + sizeof (UINT64); - } - break; + break; - case EFI_IMAGE_REL_BASED_HIGHADJ: - // - // Return the same EFI_UNSUPPORTED return code as - // PeCoffLoaderRelocateImageEx() returns if it does not recognize - // the relocation type. - // - ImageContext->ImageError = IMAGE_ERROR_FAILED_RELOCATION; - return RETURN_UNSUPPORTED; + case EFI_IMAGE_REL_BASED_HIGHLOW: + F32 = (UINT32 *)Fixup; + *F32 = *F32 + (UINT32)Adjust; + if (FixupData != NULL) { + FixupData = ALIGN_POINTER (FixupData, sizeof (UINT32)); + *(UINT32 *)FixupData = *F32; + FixupData = FixupData + sizeof (UINT32); + } - default: - switch (MachineType) { - case EFI_IMAGE_MACHINE_IA32: - Status = PeCoffLoaderRelocateIa32Image (Reloc, Fixup, &FixupData, Adjust); - break; - case EFI_IMAGE_MACHINE_ARMT: - Status = PeCoffLoaderRelocateArmImage (&Reloc, Fixup, &FixupData, Adjust); - break; - case EFI_IMAGE_MACHINE_RISCV64: - Status = PeCoffLoaderRelocateRiscVImage (Reloc, Fixup, &FixupData, Adjust); break; - case EFI_IMAGE_MACHINE_LOONGARCH64: - Status = PeCoffLoaderRelocateLoongArch64Image (Reloc, Fixup, &FixupData, Adjust); - break; - default: - Status = RETURN_UNSUPPORTED; + + case EFI_IMAGE_REL_BASED_DIR64: + F64 = (UINT64 *)Fixup; + *F64 = *F64 + (UINT64)Adjust; + if (FixupData != NULL) { + FixupData = ALIGN_POINTER (FixupData, sizeof (UINT64)); + *(UINT64 *)FixupData = *F64; + FixupData = FixupData + sizeof (UINT64); + } + break; - } - if (RETURN_ERROR (Status)) { + + case EFI_IMAGE_REL_BASED_HIGHADJ: + // + // Return the same EFI_UNSUPPORTED return code as + // PeCoffLoaderRelocateImageEx() returns if it does not recognize + // the relocation type. + // ImageContext->ImageError = IMAGE_ERROR_FAILED_RELOCATION; - return Status; - } + return RETURN_UNSUPPORTED; + + default: + switch (MachineType) { + case EFI_IMAGE_MACHINE_IA32: + Status = PeCoffLoaderRelocateIa32Image (Reloc, Fixup, &FixupData, Adjust); + break; + case EFI_IMAGE_MACHINE_ARMT: + Status = PeCoffLoaderRelocateArmImage (&Reloc, Fixup, &FixupData, Adjust); + break; + case EFI_IMAGE_MACHINE_RISCV64: + Status = PeCoffLoaderRelocateRiscVImage (Reloc, Fixup, &FixupData, Adjust); + break; + case EFI_IMAGE_MACHINE_LOONGARCH64: + Status = PeCoffLoaderRelocateLoongArch64Image (Reloc, Fixup, &FixupData, Adjust); + break; + default: + Status = RETURN_UNSUPPORTED; + break; + } + + if (RETURN_ERROR (Status)) { + ImageContext->ImageError = IMAGE_ERROR_FAILED_RELOCATION; + return Status; + } } // @@ -805,7 +815,7 @@ PeCoffLoaderRelocateImage ( // // Next reloc block // - RelocBase = (EFI_IMAGE_BASE_RELOCATION *) RelocEnd; + RelocBase = (EFI_IMAGE_BASE_RELOCATION *)RelocEnd; } return RETURN_SUCCESS; @@ -829,25 +839,25 @@ PeCoffLoaderLoadImage ( IN OUT PE_COFF_LOADER_IMAGE_CONTEXT *ImageContext ) { - RETURN_STATUS Status; - EFI_IMAGE_OPTIONAL_HEADER_UNION *PeHdr; - EFI_TE_IMAGE_HEADER *TeHdr; - PE_COFF_LOADER_IMAGE_CONTEXT CheckContext; - EFI_IMAGE_SECTION_HEADER *FirstSection; - EFI_IMAGE_SECTION_HEADER *Section; - UINTN NumberOfSections; - UINTN Index; - CHAR8 *Base; - CHAR8 *End; - CHAR8 *MaxEnd; - EFI_IMAGE_DATA_DIRECTORY *DirectoryEntry; - EFI_IMAGE_DEBUG_DIRECTORY_ENTRY *DebugEntry; - UINTN Size; - UINT32 TempDebugEntryRva; - EFI_IMAGE_OPTIONAL_HEADER_POINTER OptionHeader; + RETURN_STATUS Status; + EFI_IMAGE_OPTIONAL_HEADER_UNION *PeHdr; + EFI_TE_IMAGE_HEADER *TeHdr; + PE_COFF_LOADER_IMAGE_CONTEXT CheckContext; + EFI_IMAGE_SECTION_HEADER *FirstSection; + EFI_IMAGE_SECTION_HEADER *Section; + UINTN NumberOfSections; + UINTN Index; + CHAR8 *Base; + CHAR8 *End; + CHAR8 *MaxEnd; + EFI_IMAGE_DATA_DIRECTORY *DirectoryEntry; + EFI_IMAGE_DEBUG_DIRECTORY_ENTRY *DebugEntry; + UINTN Size; + UINT32 TempDebugEntryRva; + EFI_IMAGE_OPTIONAL_HEADER_POINTER OptionHeader; - PeHdr = NULL; - TeHdr = NULL; + PeHdr = NULL; + TeHdr = NULL; OptionHeader.Header = NULL; // // Assume success @@ -887,6 +897,7 @@ PeCoffLoaderLoadImage ( ImageContext->ImageError = IMAGE_ERROR_INVALID_SUBSYSTEM; return RETURN_LOAD_ERROR; } + // // If the image does not contain relocations, and the requested load address // is not the linked address, then return an error. @@ -896,6 +907,7 @@ PeCoffLoaderLoadImage ( return RETURN_INVALID_PARAMETER; } } + // // Make sure the allocated space has the proper section alignment // @@ -905,46 +917,46 @@ PeCoffLoaderLoadImage ( return RETURN_INVALID_PARAMETER; } } + // // Read the entire PE/COFF or TE header into memory // if (!(ImageContext->IsTeImage)) { Status = ImageContext->ImageRead ( - ImageContext->Handle, - 0, - &ImageContext->SizeOfHeaders, - (VOID *) (UINTN) ImageContext->ImageAddress - ); + ImageContext->Handle, + 0, + &ImageContext->SizeOfHeaders, + (VOID *)(UINTN)ImageContext->ImageAddress + ); PeHdr = (EFI_IMAGE_OPTIONAL_HEADER_UNION *) - ((UINTN)ImageContext->ImageAddress + ImageContext->PeCoffHeaderOffset); + ((UINTN)ImageContext->ImageAddress + ImageContext->PeCoffHeaderOffset); - OptionHeader.Header = (VOID *) &(PeHdr->Pe32.OptionalHeader); + OptionHeader.Header = (VOID *)&(PeHdr->Pe32.OptionalHeader); - FirstSection = (EFI_IMAGE_SECTION_HEADER *) ( - (UINTN)ImageContext->ImageAddress + - ImageContext->PeCoffHeaderOffset + - sizeof(UINT32) + - sizeof(EFI_IMAGE_FILE_HEADER) + - PeHdr->Pe32.FileHeader.SizeOfOptionalHeader - ); - NumberOfSections = (UINTN) (PeHdr->Pe32.FileHeader.NumberOfSections); + FirstSection = (EFI_IMAGE_SECTION_HEADER *)( + (UINTN)ImageContext->ImageAddress + + ImageContext->PeCoffHeaderOffset + + sizeof (UINT32) + + sizeof (EFI_IMAGE_FILE_HEADER) + + PeHdr->Pe32.FileHeader.SizeOfOptionalHeader + ); + NumberOfSections = (UINTN)(PeHdr->Pe32.FileHeader.NumberOfSections); } else { Status = ImageContext->ImageRead ( - ImageContext->Handle, - 0, - &ImageContext->SizeOfHeaders, - (VOID *) (UINTN) ImageContext->ImageAddress - ); + ImageContext->Handle, + 0, + &ImageContext->SizeOfHeaders, + (VOID *)(UINTN)ImageContext->ImageAddress + ); - TeHdr = (EFI_TE_IMAGE_HEADER *) (UINTN) (ImageContext->ImageAddress); - - FirstSection = (EFI_IMAGE_SECTION_HEADER *) ( - (UINTN)ImageContext->ImageAddress + - sizeof(EFI_TE_IMAGE_HEADER) - ); - NumberOfSections = (UINTN) (TeHdr->NumberOfSections); + TeHdr = (EFI_TE_IMAGE_HEADER *)(UINTN)(ImageContext->ImageAddress); + FirstSection = (EFI_IMAGE_SECTION_HEADER *)( + (UINTN)ImageContext->ImageAddress + + sizeof (EFI_TE_IMAGE_HEADER) + ); + NumberOfSections = (UINTN)(TeHdr->NumberOfSections); } if (RETURN_ERROR (Status)) { @@ -957,15 +969,14 @@ PeCoffLoaderLoadImage ( // Section = FirstSection; for (Index = 0, MaxEnd = NULL; Index < NumberOfSections; Index++) { - // // Compute sections address // Base = PeCoffLoaderImageAddress (ImageContext, Section->VirtualAddress); - End = PeCoffLoaderImageAddress ( - ImageContext, - Section->VirtualAddress + Section->Misc.VirtualSize - 1 - ); + End = PeCoffLoaderImageAddress ( + ImageContext, + Section->VirtualAddress + Section->Misc.VirtualSize - 1 + ); // // If the base start or end address resolved to 0, then fail. @@ -975,10 +986,9 @@ PeCoffLoaderLoadImage ( return RETURN_LOAD_ERROR; } - if (ImageContext->IsTeImage) { - Base = (CHAR8 *) ((UINTN) Base + sizeof (EFI_TE_IMAGE_HEADER) - (UINTN) TeHdr->StrippedSize); - End = (CHAR8 *) ((UINTN) End + sizeof (EFI_TE_IMAGE_HEADER) - (UINTN) TeHdr->StrippedSize); + Base = (CHAR8 *)((UINTN)Base + sizeof (EFI_TE_IMAGE_HEADER) - (UINTN)TeHdr->StrippedSize); + End = (CHAR8 *)((UINTN)End + sizeof (EFI_TE_IMAGE_HEADER) - (UINTN)TeHdr->StrippedSize); } if (End > MaxEnd) { @@ -988,26 +998,26 @@ PeCoffLoaderLoadImage ( // // Read the section // - Size = (UINTN) Section->Misc.VirtualSize; + Size = (UINTN)Section->Misc.VirtualSize; if ((Size == 0) || (Size > Section->SizeOfRawData)) { - Size = (UINTN) Section->SizeOfRawData; + Size = (UINTN)Section->SizeOfRawData; } if (Section->SizeOfRawData) { if (!(ImageContext->IsTeImage)) { Status = ImageContext->ImageRead ( - ImageContext->Handle, - Section->PointerToRawData, - &Size, - Base - ); + ImageContext->Handle, + Section->PointerToRawData, + &Size, + Base + ); } else { Status = ImageContext->ImageRead ( - ImageContext->Handle, - Section->PointerToRawData + sizeof (EFI_TE_IMAGE_HEADER) - (UINTN) TeHdr->StrippedSize, - &Size, - Base - ); + ImageContext->Handle, + Section->PointerToRawData + sizeof (EFI_TE_IMAGE_HEADER) - (UINTN)TeHdr->StrippedSize, + &Size, + Base + ); } if (RETURN_ERROR (Status)) { @@ -1034,15 +1044,15 @@ PeCoffLoaderLoadImage ( // Get image's entry point // if (!(ImageContext->IsTeImage)) { - ImageContext->EntryPoint = (PHYSICAL_ADDRESS) (UINTN) PeCoffLoaderImageAddress ( - ImageContext, - PeHdr->Pe32.OptionalHeader.AddressOfEntryPoint - ); + ImageContext->EntryPoint = (PHYSICAL_ADDRESS)(UINTN)PeCoffLoaderImageAddress ( + ImageContext, + PeHdr->Pe32.OptionalHeader.AddressOfEntryPoint + ); } else { ImageContext->EntryPoint = (UINTN)ImageContext->ImageAddress + (UINTN)TeHdr->AddressOfEntryPoint + - (UINTN)sizeof(EFI_TE_IMAGE_HEADER) - - (UINTN) TeHdr->StrippedSize; + (UINTN)sizeof (EFI_TE_IMAGE_HEADER) - + (UINTN)TeHdr->StrippedSize; } // @@ -1056,7 +1066,7 @@ PeCoffLoaderLoadImage ( if (PeHdr->Pe32.OptionalHeader.Magic == EFI_IMAGE_NT_OPTIONAL_HDR32_MAGIC) { if (OptionHeader.Optional32->NumberOfRvaAndSizes > EFI_IMAGE_DIRECTORY_ENTRY_BASERELOC) { DirectoryEntry = (EFI_IMAGE_DATA_DIRECTORY *) - &OptionHeader.Optional32->DataDirectory[EFI_IMAGE_DIRECTORY_ENTRY_BASERELOC]; + &OptionHeader.Optional32->DataDirectory[EFI_IMAGE_DIRECTORY_ENTRY_BASERELOC]; ImageContext->FixupDataSize = DirectoryEntry->Size / sizeof (UINT16) * sizeof (UINTN); } else { ImageContext->FixupDataSize = 0; @@ -1064,7 +1074,7 @@ PeCoffLoaderLoadImage ( } else { if (OptionHeader.Optional64->NumberOfRvaAndSizes > EFI_IMAGE_DIRECTORY_ENTRY_BASERELOC) { DirectoryEntry = (EFI_IMAGE_DATA_DIRECTORY *) - &OptionHeader.Optional64->DataDirectory[EFI_IMAGE_DIRECTORY_ENTRY_BASERELOC]; + &OptionHeader.Optional64->DataDirectory[EFI_IMAGE_DIRECTORY_ENTRY_BASERELOC]; ImageContext->FixupDataSize = DirectoryEntry->Size / sizeof (UINT16) * sizeof (UINTN); } else { ImageContext->FixupDataSize = 0; @@ -1074,6 +1084,7 @@ PeCoffLoaderLoadImage ( DirectoryEntry = &TeHdr->DataDirectory[0]; ImageContext->FixupDataSize = DirectoryEntry->Size / sizeof (UINT16) * sizeof (UINTN); } + // // Consumer must allocate a buffer for the relocation fixup log. // Only used for runtime drivers. @@ -1086,23 +1097,23 @@ PeCoffLoaderLoadImage ( if (ImageContext->DebugDirectoryEntryRva != 0) { if (!(ImageContext->IsTeImage)) { DebugEntry = PeCoffLoaderImageAddress ( - ImageContext, - ImageContext->DebugDirectoryEntryRva - ); + ImageContext, + ImageContext->DebugDirectoryEntryRva + ); } else { DebugEntry = (EFI_IMAGE_DEBUG_DIRECTORY_ENTRY *)(UINTN)( - ImageContext->ImageAddress + - ImageContext->DebugDirectoryEntryRva + - sizeof(EFI_TE_IMAGE_HEADER) - - TeHdr->StrippedSize - ); + ImageContext->ImageAddress + + ImageContext->DebugDirectoryEntryRva + + sizeof (EFI_TE_IMAGE_HEADER) - + TeHdr->StrippedSize + ); } if (DebugEntry != NULL) { TempDebugEntryRva = DebugEntry->RVA; - if (DebugEntry->RVA == 0 && DebugEntry->FileOffset != 0) { + if ((DebugEntry->RVA == 0) && (DebugEntry->FileOffset != 0)) { Section--; - if ((UINTN) Section->SizeOfRawData < Section->Misc.VirtualSize) { + if ((UINTN)Section->SizeOfRawData < Section->Misc.VirtualSize) { TempDebugEntryRva = Section->VirtualAddress + Section->Misc.VirtualSize; } else { TempDebugEntryRva = Section->VirtualAddress + Section->SizeOfRawData; @@ -1114,11 +1125,11 @@ PeCoffLoaderLoadImage ( ImageContext->CodeView = PeCoffLoaderImageAddress (ImageContext, TempDebugEntryRva); } else { ImageContext->CodeView = (VOID *)( - (UINTN)ImageContext->ImageAddress + - (UINTN)TempDebugEntryRva + - (UINTN)sizeof(EFI_TE_IMAGE_HEADER) - - (UINTN) TeHdr->StrippedSize - ); + (UINTN)ImageContext->ImageAddress + + (UINTN)TempDebugEntryRva + + (UINTN)sizeof (EFI_TE_IMAGE_HEADER) - + (UINTN)TeHdr->StrippedSize + ); } if (ImageContext->CodeView == NULL) { @@ -1130,18 +1141,18 @@ PeCoffLoaderLoadImage ( Size = DebugEntry->SizeOfData; if (!(ImageContext->IsTeImage)) { Status = ImageContext->ImageRead ( - ImageContext->Handle, - DebugEntry->FileOffset, - &Size, - ImageContext->CodeView - ); + ImageContext->Handle, + DebugEntry->FileOffset, + &Size, + ImageContext->CodeView + ); } else { Status = ImageContext->ImageRead ( - ImageContext->Handle, - DebugEntry->FileOffset + sizeof (EFI_TE_IMAGE_HEADER) - TeHdr->StrippedSize, - &Size, - ImageContext->CodeView - ); + ImageContext->Handle, + DebugEntry->FileOffset + sizeof (EFI_TE_IMAGE_HEADER) - TeHdr->StrippedSize, + &Size, + ImageContext->CodeView + ); // // Should we apply fix up to this field according to the size difference between PE and TE? // Because now we maintain TE header fields unfixed, this field will also remain as they are @@ -1157,20 +1168,20 @@ PeCoffLoaderLoadImage ( DebugEntry->RVA = TempDebugEntryRva; } - switch (*(UINT32 *) ImageContext->CodeView) { - case CODEVIEW_SIGNATURE_NB10: - ImageContext->PdbPointer = (CHAR8 *) ImageContext->CodeView + sizeof (EFI_IMAGE_DEBUG_CODEVIEW_NB10_ENTRY); - break; + switch (*(UINT32 *)ImageContext->CodeView) { + case CODEVIEW_SIGNATURE_NB10: + ImageContext->PdbPointer = (CHAR8 *)ImageContext->CodeView + sizeof (EFI_IMAGE_DEBUG_CODEVIEW_NB10_ENTRY); + break; - case CODEVIEW_SIGNATURE_RSDS: - ImageContext->PdbPointer = (CHAR8 *) ImageContext->CodeView + sizeof (EFI_IMAGE_DEBUG_CODEVIEW_RSDS_ENTRY); - break; + case CODEVIEW_SIGNATURE_RSDS: + ImageContext->PdbPointer = (CHAR8 *)ImageContext->CodeView + sizeof (EFI_IMAGE_DEBUG_CODEVIEW_RSDS_ENTRY); + break; - case CODEVIEW_SIGNATURE_MTOC: - ImageContext->PdbPointer = (CHAR8 *) ImageContext->CodeView + sizeof (EFI_IMAGE_DEBUG_CODEVIEW_MTOC_ENTRY); + case CODEVIEW_SIGNATURE_MTOC: + ImageContext->PdbPointer = (CHAR8 *)ImageContext->CodeView + sizeof (EFI_IMAGE_DEBUG_CODEVIEW_MTOC_ENTRY); - default: - break; + default: + break; } } } @@ -1204,17 +1215,17 @@ PeCoffLoaderGetPdbPointer ( IN VOID *Pe32Data ) { - EFI_IMAGE_DOS_HEADER *DosHdr; - EFI_IMAGE_OPTIONAL_HEADER_PTR_UNION Hdr; - EFI_IMAGE_DATA_DIRECTORY *DirectoryEntry; - EFI_IMAGE_DEBUG_DIRECTORY_ENTRY *DebugEntry; - UINTN DirCount; - VOID *CodeViewEntryPointer; - INTN TEImageAdjust; - UINT32 NumberOfRvaAndSizes; - UINT16 Magic; - EFI_IMAGE_SECTION_HEADER *SectionHeader; - UINT32 Index, Index1; + EFI_IMAGE_DOS_HEADER *DosHdr; + EFI_IMAGE_OPTIONAL_HEADER_PTR_UNION Hdr; + EFI_IMAGE_DATA_DIRECTORY *DirectoryEntry; + EFI_IMAGE_DEBUG_DIRECTORY_ENTRY *DebugEntry; + UINTN DirCount; + VOID *CodeViewEntryPointer; + INTN TEImageAdjust; + UINT32 NumberOfRvaAndSizes; + UINT16 Magic; + EFI_IMAGE_SECTION_HEADER *SectionHeader; + UINT32 Index, Index1; if (Pe32Data == NULL) { return NULL; @@ -1233,7 +1244,7 @@ PeCoffLoaderGetPdbPointer ( // // DOS image header is present, so read the PE header after the DOS image header. // - Hdr.Pe32 = (EFI_IMAGE_NT_HEADERS32 *)((UINTN) Pe32Data + (UINTN) ((DosHdr->e_lfanew) & 0x0ffff)); + Hdr.Pe32 = (EFI_IMAGE_NT_HEADERS32 *)((UINTN)Pe32Data + (UINTN)((DosHdr->e_lfanew) & 0x0ffff)); } else { // // DOS image header is not present, so PE header is at the image base. @@ -1243,22 +1254,23 @@ PeCoffLoaderGetPdbPointer ( if (EFI_TE_IMAGE_HEADER_SIGNATURE == Hdr.Te->Signature) { if (Hdr.Te->DataDirectory[EFI_TE_IMAGE_DIRECTORY_ENTRY_DEBUG].VirtualAddress != 0) { - DirectoryEntry = &Hdr.Te->DataDirectory[EFI_TE_IMAGE_DIRECTORY_ENTRY_DEBUG]; - TEImageAdjust = sizeof (EFI_TE_IMAGE_HEADER) - Hdr.Te->StrippedSize; + DirectoryEntry = &Hdr.Te->DataDirectory[EFI_TE_IMAGE_DIRECTORY_ENTRY_DEBUG]; + TEImageAdjust = sizeof (EFI_TE_IMAGE_HEADER) - Hdr.Te->StrippedSize; // // Get the DebugEntry offset in the raw data image. // - SectionHeader = (EFI_IMAGE_SECTION_HEADER *) (Hdr.Te + 1); - Index = Hdr.Te->NumberOfSections; - for (Index1 = 0; Index1 < Index; Index1 ++) { + SectionHeader = (EFI_IMAGE_SECTION_HEADER *)(Hdr.Te + 1); + Index = Hdr.Te->NumberOfSections; + for (Index1 = 0; Index1 < Index; Index1++) { if ((DirectoryEntry->VirtualAddress >= SectionHeader[Index1].VirtualAddress) && - (DirectoryEntry->VirtualAddress < (SectionHeader[Index1].VirtualAddress + SectionHeader[Index1].Misc.VirtualSize))) { - DebugEntry = (EFI_IMAGE_DEBUG_DIRECTORY_ENTRY *)((UINTN) Hdr.Te + - DirectoryEntry->VirtualAddress - - SectionHeader [Index1].VirtualAddress + - SectionHeader [Index1].PointerToRawData + - TEImageAdjust); + (DirectoryEntry->VirtualAddress < (SectionHeader[Index1].VirtualAddress + SectionHeader[Index1].Misc.VirtualSize))) + { + DebugEntry = (EFI_IMAGE_DEBUG_DIRECTORY_ENTRY *)((UINTN)Hdr.Te + + DirectoryEntry->VirtualAddress - + SectionHeader[Index1].VirtualAddress + + SectionHeader[Index1].PointerToRawData + + TEImageAdjust); break; } } @@ -1270,32 +1282,32 @@ PeCoffLoaderGetPdbPointer ( // generate PE32+ image with PE32 Magic. // switch (Hdr.Pe32->FileHeader.Machine) { - case EFI_IMAGE_MACHINE_IA32: - case EFI_IMAGE_MACHINE_ARMT: - // - // Assume PE32 image with IA32 Machine field. - // - Magic = EFI_IMAGE_NT_OPTIONAL_HDR32_MAGIC; - break; - case EFI_IMAGE_MACHINE_X64: - // - // Assume PE32+ image with X64 Machine field - // - Magic = EFI_IMAGE_NT_OPTIONAL_HDR64_MAGIC; - break; - default: - // - // For unknown Machine field, use Magic in optional Header - // - Magic = Hdr.Pe32->OptionalHeader.Magic; + case EFI_IMAGE_MACHINE_IA32: + case EFI_IMAGE_MACHINE_ARMT: + // + // Assume PE32 image with IA32 Machine field. + // + Magic = EFI_IMAGE_NT_OPTIONAL_HDR32_MAGIC; + break; + case EFI_IMAGE_MACHINE_X64: + // + // Assume PE32+ image with X64 Machine field + // + Magic = EFI_IMAGE_NT_OPTIONAL_HDR64_MAGIC; + break; + default: + // + // For unknown Machine field, use Magic in optional Header + // + Magic = Hdr.Pe32->OptionalHeader.Magic; } - SectionHeader = (EFI_IMAGE_SECTION_HEADER *) ( - (UINT8 *) Hdr.Pe32 + - sizeof (UINT32) + - sizeof (EFI_IMAGE_FILE_HEADER) + - Hdr.Pe32->FileHeader.SizeOfOptionalHeader - ); + SectionHeader = (EFI_IMAGE_SECTION_HEADER *)( + (UINT8 *)Hdr.Pe32 + + sizeof (UINT32) + + sizeof (EFI_IMAGE_FILE_HEADER) + + Hdr.Pe32->FileHeader.SizeOfOptionalHeader + ); Index = Hdr.Pe32->FileHeader.NumberOfSections; if (EFI_IMAGE_NT_OPTIONAL_HDR32_MAGIC == Magic) { @@ -1303,30 +1315,31 @@ PeCoffLoaderGetPdbPointer ( // Use PE32 offset get Debug Directory Entry // NumberOfRvaAndSizes = Hdr.Pe32->OptionalHeader.NumberOfRvaAndSizes; - DirectoryEntry = (EFI_IMAGE_DATA_DIRECTORY *)&(Hdr.Pe32->OptionalHeader.DataDirectory[EFI_IMAGE_DIRECTORY_ENTRY_DEBUG]); + DirectoryEntry = (EFI_IMAGE_DATA_DIRECTORY *)&(Hdr.Pe32->OptionalHeader.DataDirectory[EFI_IMAGE_DIRECTORY_ENTRY_DEBUG]); } else if (Hdr.Pe32->OptionalHeader.Magic == EFI_IMAGE_NT_OPTIONAL_HDR64_MAGIC) { // // Use PE32+ offset get Debug Directory Entry // NumberOfRvaAndSizes = Hdr.Pe32Plus->OptionalHeader.NumberOfRvaAndSizes; - DirectoryEntry = (EFI_IMAGE_DATA_DIRECTORY *)&(Hdr.Pe32Plus->OptionalHeader.DataDirectory[EFI_IMAGE_DIRECTORY_ENTRY_DEBUG]); + DirectoryEntry = (EFI_IMAGE_DATA_DIRECTORY *)&(Hdr.Pe32Plus->OptionalHeader.DataDirectory[EFI_IMAGE_DIRECTORY_ENTRY_DEBUG]); } - if (NumberOfRvaAndSizes <= EFI_IMAGE_DIRECTORY_ENTRY_DEBUG || DirectoryEntry->VirtualAddress == 0) { + if ((NumberOfRvaAndSizes <= EFI_IMAGE_DIRECTORY_ENTRY_DEBUG) || (DirectoryEntry->VirtualAddress == 0)) { DirectoryEntry = NULL; - DebugEntry = NULL; + DebugEntry = NULL; } else { // // Get the DebugEntry offset in the raw data image. // - for (Index1 = 0; Index1 < Index; Index1 ++) { + for (Index1 = 0; Index1 < Index; Index1++) { if ((DirectoryEntry->VirtualAddress >= SectionHeader[Index1].VirtualAddress) && - (DirectoryEntry->VirtualAddress < (SectionHeader[Index1].VirtualAddress + SectionHeader[Index1].Misc.VirtualSize))) { - DebugEntry = (EFI_IMAGE_DEBUG_DIRECTORY_ENTRY *) ( - (UINTN) Pe32Data + - DirectoryEntry->VirtualAddress - - SectionHeader[Index1].VirtualAddress + - SectionHeader[Index1].PointerToRawData); + (DirectoryEntry->VirtualAddress < (SectionHeader[Index1].VirtualAddress + SectionHeader[Index1].Misc.VirtualSize))) + { + DebugEntry = (EFI_IMAGE_DEBUG_DIRECTORY_ENTRY *)( + (UINTN)Pe32Data + + DirectoryEntry->VirtualAddress - + SectionHeader[Index1].VirtualAddress + + SectionHeader[Index1].PointerToRawData); break; } } @@ -1335,7 +1348,7 @@ PeCoffLoaderGetPdbPointer ( return NULL; } - if (NULL == DebugEntry || NULL == DirectoryEntry) { + if ((NULL == DebugEntry) || (NULL == DirectoryEntry)) { return NULL; } @@ -1349,33 +1362,36 @@ PeCoffLoaderGetPdbPointer ( // Get the DebugEntry offset in the raw data image. // CodeViewEntryPointer = NULL; - for (Index1 = 0; Index1 < Index; Index1 ++) { + for (Index1 = 0; Index1 < Index; Index1++) { if ((DebugEntry->RVA >= SectionHeader[Index1].VirtualAddress) && - (DebugEntry->RVA < (SectionHeader[Index1].VirtualAddress + SectionHeader[Index1].Misc.VirtualSize))) { - CodeViewEntryPointer = (VOID *) ( - ((UINTN)Pe32Data) + - (UINTN) DebugEntry->RVA - - SectionHeader[Index1].VirtualAddress + - SectionHeader[Index1].PointerToRawData + - (UINTN)TEImageAdjust); + (DebugEntry->RVA < (SectionHeader[Index1].VirtualAddress + SectionHeader[Index1].Misc.VirtualSize))) + { + CodeViewEntryPointer = (VOID *)( + ((UINTN)Pe32Data) + + (UINTN)DebugEntry->RVA - + SectionHeader[Index1].VirtualAddress + + SectionHeader[Index1].PointerToRawData + + (UINTN)TEImageAdjust); break; } } + if (Index1 >= Index) { // // Can't find CodeViewEntryPointer in raw PE/COFF image. // continue; } - switch (* (UINT32 *) CodeViewEntryPointer) { - case CODEVIEW_SIGNATURE_NB10: - return (VOID *) ((CHAR8 *)CodeViewEntryPointer + sizeof (EFI_IMAGE_DEBUG_CODEVIEW_NB10_ENTRY)); - case CODEVIEW_SIGNATURE_RSDS: - return (VOID *) ((CHAR8 *)CodeViewEntryPointer + sizeof (EFI_IMAGE_DEBUG_CODEVIEW_RSDS_ENTRY)); - case CODEVIEW_SIGNATURE_MTOC: - return (VOID *) ((CHAR8 *)CodeViewEntryPointer + sizeof (EFI_IMAGE_DEBUG_CODEVIEW_MTOC_ENTRY)); - default: - break; + + switch (*(UINT32 *)CodeViewEntryPointer) { + case CODEVIEW_SIGNATURE_NB10: + return (VOID *)((CHAR8 *)CodeViewEntryPointer + sizeof (EFI_IMAGE_DEBUG_CODEVIEW_NB10_ENTRY)); + case CODEVIEW_SIGNATURE_RSDS: + return (VOID *)((CHAR8 *)CodeViewEntryPointer + sizeof (EFI_IMAGE_DEBUG_CODEVIEW_RSDS_ENTRY)); + case CODEVIEW_SIGNATURE_MTOC: + return (VOID *)((CHAR8 *)CodeViewEntryPointer + sizeof (EFI_IMAGE_DEBUG_CODEVIEW_MTOC_ENTRY)); + default: + break; } } } @@ -1384,7 +1400,6 @@ PeCoffLoaderGetPdbPointer ( return NULL; } - RETURN_STATUS EFIAPI PeCoffLoaderGetEntryPoint ( @@ -1393,15 +1408,15 @@ PeCoffLoaderGetEntryPoint ( OUT VOID **BaseOfImage ) { - EFI_IMAGE_DOS_HEADER *DosHdr; - EFI_IMAGE_OPTIONAL_HEADER_PTR_UNION Hdr; + EFI_IMAGE_DOS_HEADER *DosHdr; + EFI_IMAGE_OPTIONAL_HEADER_PTR_UNION Hdr; DosHdr = (EFI_IMAGE_DOS_HEADER *)Pe32Data; if (DosHdr->e_magic == EFI_IMAGE_DOS_SIGNATURE) { // // DOS image header is present, so read the PE header after the DOS image header. // - Hdr.Pe32 = (EFI_IMAGE_NT_HEADERS32 *)((UINTN) Pe32Data + (UINTN) ((DosHdr->e_lfanew) & 0x0ffff)); + Hdr.Pe32 = (EFI_IMAGE_NT_HEADERS32 *)((UINTN)Pe32Data + (UINTN)((DosHdr->e_lfanew) & 0x0ffff)); } else { // // DOS image header is not present, so PE header is at the image base. @@ -1415,7 +1430,7 @@ PeCoffLoaderGetEntryPoint ( // if (Hdr.Te->Signature == EFI_TE_IMAGE_HEADER_SIGNATURE) { *BaseOfImage = (VOID *)(UINTN)(Hdr.Te->ImageBase + Hdr.Te->StrippedSize - sizeof (EFI_TE_IMAGE_HEADER)); - *EntryPoint = (VOID *)((UINTN)*BaseOfImage + (Hdr.Te->AddressOfEntryPoint & 0x0ffffffff) + sizeof(EFI_TE_IMAGE_HEADER) - Hdr.Te->StrippedSize); + *EntryPoint = (VOID *)((UINTN)*BaseOfImage + (Hdr.Te->AddressOfEntryPoint & 0x0ffffffff) + sizeof (EFI_TE_IMAGE_HEADER) - Hdr.Te->StrippedSize); return RETURN_SUCCESS; } else if (Hdr.Pe32->Signature == EFI_IMAGE_NT_SIGNATURE) { *EntryPoint = (VOID *)(UINTN)Hdr.Pe32->OptionalHeader.AddressOfEntryPoint; @@ -1424,6 +1439,7 @@ PeCoffLoaderGetEntryPoint ( } else { *BaseOfImage = (VOID *)(UINTN)Hdr.Pe32Plus->OptionalHeader.ImageBase; } + *EntryPoint = (VOID *)(UINTN)((UINTN)*EntryPoint + (UINTN)*BaseOfImage); return RETURN_SUCCESS; } diff --git a/BaseTools/Source/C/Common/BinderFuncs.c b/BaseTools/Source/C/Common/BinderFuncs.c index de835287e95c..be256c1fd29a 100644 --- a/BaseTools/Source/C/Common/BinderFuncs.c +++ b/BaseTools/Source/C/Common/BinderFuncs.c @@ -17,15 +17,15 @@ SPDX-License-Identifier: BSD-2-Clause-Patent VOID * CommonLibBinderAllocate ( - IN UINTN Size + IN UINTN Size ) { - return (VOID *) malloc (Size); + return (VOID *)malloc (Size); } VOID CommonLibBinderFree ( - IN VOID *Pointer + IN VOID *Pointer ) { free (Pointer); @@ -33,9 +33,9 @@ CommonLibBinderFree ( VOID CommonLibBinderCopyMem ( - IN VOID *Destination, - IN VOID *Source, - IN UINTN Length + IN VOID *Destination, + IN VOID *Source, + IN UINTN Length ) { memmove (Destination, Source, Length); @@ -43,9 +43,9 @@ CommonLibBinderCopyMem ( VOID CommonLibBinderSetMem ( - IN VOID *Destination, - IN UINTN Length, - IN UINT8 Value + IN VOID *Destination, + IN UINTN Length, + IN UINT8 Value ) { memset (Destination, Value, Length); @@ -53,9 +53,9 @@ CommonLibBinderSetMem ( INTN CommonLibBinderCompareMem ( - IN VOID *MemOne, - IN VOID *MemTwo, - IN UINTN Length + IN VOID *MemOne, + IN VOID *MemTwo, + IN UINTN Length ) { return memcmp (MemOne, MemTwo, Length); @@ -63,12 +63,9 @@ CommonLibBinderCompareMem ( BOOLEAN CommonLibBinderCompareGuid ( - IN EFI_GUID *Guid1, - IN EFI_GUID *Guid2 + IN EFI_GUID *Guid1, + IN EFI_GUID *Guid2 ) { return CompareGuid (Guid1, Guid2) ? FALSE : TRUE; } - - - diff --git a/BaseTools/Source/C/Common/CommonLib.c b/BaseTools/Source/C/Common/CommonLib.c index cd270f9a9074..861426dd8d3f 100644 --- a/BaseTools/Source/C/Common/CommonLib.c +++ b/BaseTools/Source/C/Common/CommonLib.c @@ -11,9 +11,9 @@ SPDX-License-Identifier: BSD-2-Clause-Patent #include #include #ifdef __GNUC__ -#include + #include #else -#include + #include #endif #include "CommonLib.h" #include "EfiUtilityMsgs.h" @@ -60,11 +60,11 @@ PeiCopyMem ( IN UINTN Length ) { - CHAR8 *Destination8; - CHAR8 *Source8; + CHAR8 *Destination8; + CHAR8 *Source8; - Destination8 = Destination; - Source8 = Source; + Destination8 = Destination; + Source8 = Source; while (Length--) { *(Destination8++) = *(Source8++); } @@ -100,21 +100,21 @@ CopyMem ( **/ INTN CompareGuid ( - IN EFI_GUID *Guid1, - IN EFI_GUID *Guid2 + IN EFI_GUID *Guid1, + IN EFI_GUID *Guid2 ) { - INT32 *g1; - INT32 *g2; - INT32 r; + INT32 *g1; + INT32 *g2; + INT32 r; // // Compare 32 bits at a time // - g1 = (INT32 *) Guid1; - g2 = (INT32 *) Guid2; + g1 = (INT32 *)Guid1; + g2 = (INT32 *)Guid2; - r = g1[0] - g2[0]; + r = g1[0] - g2[0]; r |= g1[1] - g2[1]; r |= g1[2] - g2[2]; r |= g1[3] - g2[3]; @@ -148,9 +148,10 @@ GetFileImage ( // // Verify input parameters. // - if (InputFileName == NULL || strlen (InputFileName) == 0 || InputFileImage == NULL) { + if ((InputFileName == NULL) || (strlen (InputFileName) == 0) || (InputFileImage == NULL)) { return EFI_INVALID_PARAMETER; } + // // Open the file and copy contents into a memory buffer. // @@ -162,6 +163,7 @@ GetFileImage ( Error (NULL, 0, 0001, "Error opening the input file", InputFileName); return EFI_ABORTED; } + // // Go to the end so that we can determine the file size // @@ -170,6 +172,7 @@ GetFileImage ( fclose (InputFile); return EFI_ABORTED; } + // // Get the file size // @@ -179,6 +182,7 @@ GetFileImage ( fclose (InputFile); return EFI_ABORTED; } + // // Allocate a buffer // @@ -187,6 +191,7 @@ GetFileImage ( fclose (InputFile); return EFI_OUT_OF_RESOURCES; } + // // Reset to the beginning of the file // @@ -197,6 +202,7 @@ GetFileImage ( *InputFileImage = NULL; return EFI_ABORTED; } + // // Read all of the file contents. // @@ -208,6 +214,7 @@ GetFileImage ( *InputFileImage = NULL; return EFI_ABORTED; } + // // Close the file // @@ -230,9 +237,9 @@ GetFileImage ( **/ EFI_STATUS PutFileImage ( - IN CHAR8 *OutputFileName, - IN CHAR8 *OutputFileImage, - IN UINT32 BytesToWrite + IN CHAR8 *OutputFileName, + IN CHAR8 *OutputFileImage, + IN UINT32 BytesToWrite ) { FILE *OutputFile; @@ -241,9 +248,10 @@ PutFileImage ( // // Verify input parameters. // - if (OutputFileName == NULL || strlen (OutputFileName) == 0 || OutputFileImage == NULL) { + if ((OutputFileName == NULL) || (strlen (OutputFileName) == 0) || (OutputFileImage == NULL)) { return EFI_INVALID_PARAMETER; } + // // Open the file and copy contents into a memory buffer. // @@ -265,6 +273,7 @@ PutFileImage ( fclose (OutputFile); return EFI_ABORTED; } + // // Close the file // @@ -283,11 +292,11 @@ PutFileImage ( **/ UINT8 CalculateChecksum8 ( - IN UINT8 *Buffer, - IN UINTN Size + IN UINT8 *Buffer, + IN UINTN Size ) { - return (UINT8) (0x100 - CalculateSum8 (Buffer, Size)); + return (UINT8)(0x100 - CalculateSum8 (Buffer, Size)); } /** @@ -304,8 +313,8 @@ CalculateSum8 ( IN UINTN Size ) { - UINTN Index; - UINT8 Sum; + UINTN Index; + UINT8 Sum; Sum = 0; @@ -313,7 +322,7 @@ CalculateSum8 ( // Perform the byte sum for buffer // for (Index = 0; Index < Size; Index++) { - Sum = (UINT8) (Sum + Buffer[Index]); + Sum = (UINT8)(Sum + Buffer[Index]); } return Sum; @@ -324,16 +333,16 @@ CalculateSum8 ( @param Buffer Pointer to buffer containing byte data of component. @param Size Size of the buffer - + @return The 16 bit checksum value needed. **/ UINT16 CalculateChecksum16 ( - IN UINT16 *Buffer, - IN UINTN Size + IN UINT16 *Buffer, + IN UINTN Size ) { - return (UINT16) (0x10000 - CalculateSum16 (Buffer, Size)); + return (UINT16)(0x10000 - CalculateSum16 (Buffer, Size)); } /** @@ -346,8 +355,8 @@ CalculateChecksum16 ( **/ UINT16 CalculateSum16 ( - IN UINT16 *Buffer, - IN UINTN Size + IN UINT16 *Buffer, + IN UINTN Size ) { UINTN Index; @@ -359,10 +368,10 @@ CalculateSum16 ( // Perform the word sum for buffer // for (Index = 0; Index < Size; Index++) { - Sum = (UINT16) (Sum + Buffer[Index]); + Sum = (UINT16)(Sum + Buffer[Index]); } - return (UINT16) Sum; + return (UINT16)Sum; } /** @@ -375,7 +384,7 @@ CalculateSum16 ( **/ EFI_STATUS PrintGuid ( - IN EFI_GUID *Guid + IN EFI_GUID *Guid ) { if (Guid == NULL) { @@ -385,7 +394,7 @@ PrintGuid ( printf ( "%08x-%04x-%04x-%02x%02x-%02x%02x%02x%02x%02x%02x\n", - (unsigned) Guid->Data1, + (unsigned)Guid->Data1, Guid->Data2, Guid->Data3, Guid->Data4[0], @@ -414,10 +423,10 @@ PrintGuid ( **/ EFI_STATUS PrintGuidToBuffer ( - IN EFI_GUID *Guid, - IN OUT UINT8 *Buffer, - IN UINT32 BufferLen, - IN BOOLEAN Uppercase + IN EFI_GUID *Guid, + IN OUT UINT8 *Buffer, + IN UINT32 BufferLen, + IN BOOLEAN Uppercase ) { if (Guid == NULL) { @@ -434,7 +443,7 @@ PrintGuidToBuffer ( sprintf ( (CHAR8 *)Buffer, "%08X-%04X-%04X-%02X%02X-%02X%02X%02X%02X%02X%02X", - (unsigned) Guid->Data1, + (unsigned)Guid->Data1, Guid->Data2, Guid->Data3, Guid->Data4[0], @@ -450,7 +459,7 @@ PrintGuidToBuffer ( sprintf ( (CHAR8 *)Buffer, "%08x-%04x-%04x-%02x%02x-%02x%02x%02x%02x%02x%02x", - (unsigned) Guid->Data1, + (unsigned)Guid->Data1, Guid->Data2, Guid->Data3, Guid->Data4[0], @@ -469,32 +478,42 @@ PrintGuidToBuffer ( #ifdef __GNUC__ -size_t _filelength(int fd) +size_t +_filelength ( + int fd + ) { - struct stat stat_buf; - fstat(fd, &stat_buf); + struct stat stat_buf; + + fstat (fd, &stat_buf); return stat_buf.st_size; } -#ifndef __CYGWIN__ -char *strlwr(char *s) + #ifndef __CYGWIN__ +char * +strlwr ( + char *s + ) { - char *p = s; - for(;*s;s++) { - *s = tolower(*s); + char *p = s; + + for ( ; *s; s++) { + *s = tolower (*s); } + return p; } -#endif + + #endif #endif -#define WINDOWS_EXTENSION_PATH "\\\\?\\" -#define WINDOWS_UNC_EXTENSION_PATH "\\\\?\\UNC" +#define WINDOWS_EXTENSION_PATH "\\\\?\\" +#define WINDOWS_UNC_EXTENSION_PATH "\\\\?\\UNC" // // Global data to store full file path. It is not required to be free. // -CHAR8 mCommonLibFullPath[MAX_LONG_FILE_PATH]; +CHAR8 mCommonLibFullPath[MAX_LONG_FILE_PATH]; /** Convert FileName to the long file path, which can support larger than 260 length. @@ -505,21 +524,21 @@ CHAR8 mCommonLibFullPath[MAX_LONG_FILE_PATH]; **/ CHAR8 * LongFilePath ( - IN CHAR8 *FileName - ) + IN CHAR8 *FileName + ) { -#ifdef __GNUC__ + #ifdef __GNUC__ // // __GNUC__ may not be good way to differentiate unix and windows. Need more investigation here. // unix has no limitation on file path. Just return FileName. // return FileName; -#else - CHAR8 *RootPath; - CHAR8 *PathPointer; - CHAR8 *NextPointer; + #else + CHAR8 *RootPath; + CHAR8 *PathPointer; + CHAR8 *NextPointer; - PathPointer = (CHAR8 *) FileName; + PathPointer = (CHAR8 *)FileName; if (FileName != NULL) { // @@ -528,13 +547,13 @@ LongFilePath ( mCommonLibFullPath[0] = 0; strcpy (mCommonLibFullPath, WINDOWS_EXTENSION_PATH); - if (strlen (FileName) > 1 && FileName[0] == '\\' && FileName[1] == '\\') { + if ((strlen (FileName) > 1) && (FileName[0] == '\\') && (FileName[1] == '\\')) { // // network path like \\server\share to \\?\UNC\server\share // strcpy (mCommonLibFullPath, WINDOWS_UNC_EXTENSION_PATH); - FileName ++; - } else if (strlen (FileName) < 3 || FileName[1] != ':' || (FileName[2] != '\\' && FileName[2] != '/')) { + FileName++; + } else if ((strlen (FileName) < 3) || (FileName[1] != ':') || ((FileName[2] != '\\') && (FileName[2] != '/'))) { // // Relative file path. Convert it to absolute path. // @@ -545,18 +564,21 @@ LongFilePath ( free (RootPath); return NULL; } + strncat (mCommonLibFullPath, RootPath, MAX_LONG_FILE_PATH - strlen (mCommonLibFullPath) - 1); - if (FileName[0] != '\\' && FileName[0] != '/') { + if ((FileName[0] != '\\') && (FileName[0] != '/')) { if (strlen (mCommonLibFullPath) + 1 > MAX_LONG_FILE_PATH - 1) { Error (NULL, 0, 2000, "Invalid parameter", "RootPath is too long!"); free (RootPath); return NULL; } + // // Attach directory separator // strncat (mCommonLibFullPath, "\\", MAX_LONG_FILE_PATH - strlen (mCommonLibFullPath) - 1); } + free (RootPath); } } @@ -568,17 +590,18 @@ LongFilePath ( Error (NULL, 0, 2000, "Invalid parameter", "FileName %s is too long!", FileName); return NULL; } + strncat (mCommonLibFullPath, FileName, MAX_LONG_FILE_PATH - strlen (mCommonLibFullPath) - 1); // // Convert directory separator '/' to '\\' // - PathPointer = (CHAR8 *) mCommonLibFullPath; + PathPointer = (CHAR8 *)mCommonLibFullPath; do { if (*PathPointer == '/') { *PathPointer = '\\'; } - } while (*PathPointer ++ != '\0'); + } while (*PathPointer++ != '\0'); // // Convert ":\\\\" to ":\\", because it doesn't work with WINDOWS_EXTENSION_PATH. @@ -610,7 +633,7 @@ LongFilePath ( while ((PathPointer = strstr (mCommonLibFullPath, "\\..\\")) != NULL) { NextPointer = PathPointer + 3; do { - PathPointer --; + PathPointer--; } while (PathPointer > mCommonLibFullPath && *PathPointer != ':' && *PathPointer != '\\'); if (*PathPointer == '\\') { @@ -631,16 +654,16 @@ LongFilePath ( } return PathPointer; -#endif + #endif } CHAR16 InternalCharToUpper ( - CHAR16 Char + CHAR16 Char ) { - if (Char >= L'a' && Char <= L'z') { - return (CHAR16) (Char - (L'a' - L'A')); + if ((Char >= L'a') && (Char <= L'z')) { + return (CHAR16)(Char - (L'a' - L'A')); } return Char; @@ -648,13 +671,13 @@ InternalCharToUpper ( UINTN StrnLenS ( - CONST CHAR16 *String, - UINTN MaxSize + CONST CHAR16 *String, + UINTN MaxSize ) { - UINTN Length; + UINTN Length; - ASSERT (((UINTN) String & BIT0) == 0); + ASSERT (((UINTN)String & BIT0) == 0); // // If String is a null pointer or MaxSize is 0, then the StrnLenS function returns zero. @@ -668,47 +691,48 @@ StrnLenS ( if (Length >= MaxSize - 1) { return MaxSize; } + Length++; } + return Length; } - VOID * InternalAllocatePool ( - UINTN AllocationSize + UINTN AllocationSize ) { - VOID * Memory; + VOID *Memory; - Memory = malloc(AllocationSize); - ASSERT(Memory != NULL); + Memory = malloc (AllocationSize); + ASSERT (Memory != NULL); return Memory; } - VOID * InternalReallocatePool ( - UINTN OldSize, - UINTN NewSize, - VOID *OldBuffer OPTIONAL + UINTN OldSize, + UINTN NewSize, + VOID *OldBuffer OPTIONAL ) { VOID *NewBuffer; NewBuffer = AllocateZeroPool (NewSize); - if (NewBuffer != NULL && OldBuffer != NULL) { + if ((NewBuffer != NULL) && (OldBuffer != NULL)) { memcpy (NewBuffer, OldBuffer, MIN (OldSize, NewSize)); - free(OldBuffer); + free (OldBuffer); } + return NewBuffer; } VOID * ReallocatePool ( - UINTN OldSize, - UINTN NewSize, - VOID *OldBuffer OPTIONAL + UINTN OldSize, + UINTN NewSize, + VOID *OldBuffer OPTIONAL ) { return InternalReallocatePool (OldSize, NewSize, OldBuffer); @@ -733,13 +757,13 @@ ReallocatePool ( **/ UINTN StrLen ( - CONST CHAR16 *String + CONST CHAR16 *String ) { - UINTN Length; + UINTN Length; ASSERT (String != NULL); - ASSERT (((UINTN) String & BIT0) == 0); + ASSERT (((UINTN)String & BIT0) == 0); for (Length = 0; *String != L'\0'; String++, Length++) { // @@ -747,21 +771,24 @@ StrLen ( // length should not more than PcdMaximumUnicodeStringLength // } + return Length; } BOOLEAN InternalSafeStringIsOverlap ( - IN VOID *Base1, - IN UINTN Size1, - IN VOID *Base2, - IN UINTN Size2 + IN VOID *Base1, + IN UINTN Size1, + IN VOID *Base2, + IN UINTN Size2 ) { if ((((UINTN)Base1 >= (UINTN)Base2) && ((UINTN)Base1 < (UINTN)Base2 + Size2)) || - (((UINTN)Base2 >= (UINTN)Base1) && ((UINTN)Base2 < (UINTN)Base1 + Size1))) { + (((UINTN)Base2 >= (UINTN)Base1) && ((UINTN)Base2 < (UINTN)Base1 + Size1))) + { return TRUE; } + return FALSE; } @@ -773,7 +800,7 @@ InternalSafeStringNoStrOverlap ( IN UINTN Size2 ) { - return !InternalSafeStringIsOverlap (Str1, Size1 * sizeof(CHAR16), Str2, Size2 * sizeof(CHAR16)); + return !InternalSafeStringIsOverlap (Str1, Size1 * sizeof (CHAR16), Str2, Size2 * sizeof (CHAR16)); } /** @@ -826,12 +853,12 @@ InternalSafeStringNoStrOverlap ( **/ RETURN_STATUS StrDecimalToUint64S ( - CONST CHAR16 *String, - CHAR16 **EndPointer, OPTIONAL - UINT64 *Data + CONST CHAR16 *String, + CHAR16 **EndPointer, OPTIONAL + UINT64 *Data ) { - ASSERT (((UINTN) String & BIT0) == 0); + ASSERT (((UINTN)String & BIT0) == 0); // // 1. Neither String nor Data shall be a null pointer. @@ -847,7 +874,7 @@ StrDecimalToUint64S ( } if (EndPointer != NULL) { - *EndPointer = (CHAR16 *) String; + *EndPointer = (CHAR16 *)String; } // @@ -875,8 +902,9 @@ StrDecimalToUint64S ( if (*Data > ((MAX_UINT64 - (*String - L'0'))/10)) { *Data = MAX_UINT64; if (EndPointer != NULL) { - *EndPointer = (CHAR16 *) String; + *EndPointer = (CHAR16 *)String; } + return RETURN_UNSUPPORTED; } @@ -885,8 +913,9 @@ StrDecimalToUint64S ( } if (EndPointer != NULL) { - *EndPointer = (CHAR16 *) String; + *EndPointer = (CHAR16 *)String; } + return RETURN_SUCCESS; } @@ -945,12 +974,12 @@ StrDecimalToUint64S ( **/ RETURN_STATUS StrHexToUint64S ( - CONST CHAR16 *String, - CHAR16 **EndPointer, OPTIONAL - UINT64 *Data + CONST CHAR16 *String, + CHAR16 **EndPointer, OPTIONAL + UINT64 *Data ) { - ASSERT (((UINTN) String & BIT0) == 0); + ASSERT (((UINTN)String & BIT0) == 0); // // 1. Neither String nor Data shall be a null pointer. @@ -966,7 +995,7 @@ StrHexToUint64S ( } if (EndPointer != NULL) { - *EndPointer = (CHAR16 *) String; + *EndPointer = (CHAR16 *)String; } // @@ -988,6 +1017,7 @@ StrHexToUint64S ( *Data = 0; return RETURN_SUCCESS; } + // // Skip the 'X' // @@ -1005,8 +1035,9 @@ StrHexToUint64S ( if (*Data > ((MAX_UINT64 - InternalHexCharToUintn (*String))>>4)) { *Data = MAX_UINT64; if (EndPointer != NULL) { - *EndPointer = (CHAR16 *) String; + *EndPointer = (CHAR16 *)String; } + return RETURN_UNSUPPORTED; } @@ -1015,46 +1046,45 @@ StrHexToUint64S ( } if (EndPointer != NULL) { - *EndPointer = (CHAR16 *) String; + *EndPointer = (CHAR16 *)String; } + return RETURN_SUCCESS; } UINT64 StrDecimalToUint64 ( - CONST CHAR16 *String + CONST CHAR16 *String ) { - UINT64 Result; + UINT64 Result; - StrDecimalToUint64S (String, (CHAR16 **) NULL, &Result); + StrDecimalToUint64S (String, (CHAR16 **)NULL, &Result); return Result; } - UINT64 StrHexToUint64 ( - CONST CHAR16 *String + CONST CHAR16 *String ) { - UINT64 Result; + UINT64 Result; - StrHexToUint64S (String, (CHAR16 **) NULL, &Result); + StrHexToUint64S (String, (CHAR16 **)NULL, &Result); return Result; } UINTN StrSize ( - CONST CHAR16 *String + CONST CHAR16 *String ) { return (StrLen (String) + 1) * sizeof (*String); } - UINT64 ReadUnaligned64 ( - CONST UINT64 *Buffer + CONST UINT64 *Buffer ) { ASSERT (Buffer != NULL); @@ -1064,8 +1094,8 @@ ReadUnaligned64 ( UINT64 WriteUnaligned64 ( - UINT64 *Buffer, - UINT64 Value + UINT64 *Buffer, + UINT64 Value ) { ASSERT (Buffer != NULL); @@ -1073,58 +1103,56 @@ WriteUnaligned64 ( return *Buffer = Value; } - EFI_GUID * CopyGuid ( - EFI_GUID *DestinationGuid, - CONST EFI_GUID *SourceGuid + EFI_GUID *DestinationGuid, + CONST EFI_GUID *SourceGuid ) { WriteUnaligned64 ( - (UINT64*)DestinationGuid, - ReadUnaligned64 ((CONST UINT64*)SourceGuid) + (UINT64 *)DestinationGuid, + ReadUnaligned64 ((CONST UINT64 *)SourceGuid) ); WriteUnaligned64 ( - (UINT64*)DestinationGuid + 1, - ReadUnaligned64 ((CONST UINT64*)SourceGuid + 1) + (UINT64 *)DestinationGuid + 1, + ReadUnaligned64 ((CONST UINT64 *)SourceGuid + 1) ); return DestinationGuid; } UINT16 SwapBytes16 ( - UINT16 Value + UINT16 Value ) { - return (UINT16) ((Value<< 8) | (Value>> 8)); + return (UINT16)((Value<< 8) | (Value>> 8)); } - UINT32 SwapBytes32 ( - UINT32 Value + UINT32 Value ) { UINT32 LowerBytes; UINT32 HigherBytes; - LowerBytes = (UINT32) SwapBytes16 ((UINT16) Value); - HigherBytes = (UINT32) SwapBytes16 ((UINT16) (Value >> 16)); + LowerBytes = (UINT32)SwapBytes16 ((UINT16)Value); + HigherBytes = (UINT32)SwapBytes16 ((UINT16)(Value >> 16)); return (LowerBytes << 16 | HigherBytes); } BOOLEAN InternalIsDecimalDigitCharacter ( - CHAR16 Char + CHAR16 Char ) { - return (BOOLEAN) (Char >= L'0' && Char <= L'9'); + return (BOOLEAN)(Char >= L'0' && Char <= L'9'); } VOID * InternalAllocateCopyPool ( - UINTN AllocationSize, - CONST VOID *Buffer + UINTN AllocationSize, + CONST VOID *Buffer ) { VOID *Memory; @@ -1133,25 +1161,25 @@ InternalAllocateCopyPool ( Memory = malloc (AllocationSize); if (Memory != NULL) { - Memory = memcpy (Memory, Buffer, AllocationSize); + Memory = memcpy (Memory, Buffer, AllocationSize); } + return Memory; } BOOLEAN InternalIsHexaDecimalDigitCharacter ( - CHAR16 Char + CHAR16 Char ) { - - return (BOOLEAN) (InternalIsDecimalDigitCharacter (Char) || - (Char >= L'A' && Char <= L'F') || - (Char >= L'a' && Char <= L'f')); + return (BOOLEAN)(InternalIsDecimalDigitCharacter (Char) || + (Char >= L'A' && Char <= L'F') || + (Char >= L'a' && Char <= L'f')); } UINTN InternalHexCharToUintn ( - CHAR16 Char + CHAR16 Char ) { if (InternalIsDecimalDigitCharacter (Char)) { @@ -1161,7 +1189,6 @@ InternalHexCharToUintn ( return (10 + InternalCharToUpper (Char) - L'A'); } - /** Convert a Null-terminated Unicode hexadecimal string to a byte array. @@ -1208,15 +1235,15 @@ InternalHexCharToUintn ( **/ RETURN_STATUS StrHexToBytes ( - CONST CHAR16 *String, - UINTN Length, - UINT8 *Buffer, - UINTN MaxBufferSize + CONST CHAR16 *String, + UINTN Length, + UINT8 *Buffer, + UINTN MaxBufferSize ) { - UINTN Index; + UINTN Index; - ASSERT (((UINTN) String & BIT0) == 0); + ASSERT (((UINTN)String & BIT0) == 0); // // 1. None of String or Buffer shall be a null pointer. @@ -1249,6 +1276,7 @@ StrHexToBytes ( break; } } + if (Index != Length) { return RETURN_UNSUPPORTED; } @@ -1256,18 +1284,18 @@ StrHexToBytes ( // // Convert the hex string to bytes. // - for(Index = 0; Index < Length; Index++) { - + for (Index = 0; Index < Length; Index++) { // // For even characters, write the upper nibble for each buffer byte, // and for even characters, the lower nibble. // if ((Index & BIT0) == 0) { - Buffer[Index / 2] = (UINT8) InternalHexCharToUintn (String[Index]) << 4; + Buffer[Index / 2] = (UINT8)InternalHexCharToUintn (String[Index]) << 4; } else { - Buffer[Index / 2] |= (UINT8) InternalHexCharToUintn (String[Index]); + Buffer[Index / 2] |= (UINT8)InternalHexCharToUintn (String[Index]); } } + return RETURN_SUCCESS; } @@ -1317,14 +1345,14 @@ StrHexToBytes ( **/ RETURN_STATUS StrToGuid ( - CONST CHAR16 *String, - EFI_GUID *Guid + CONST CHAR16 *String, + EFI_GUID *Guid ) { - RETURN_STATUS Status; - EFI_GUID LocalGuid; + RETURN_STATUS Status; + EFI_GUID LocalGuid; - ASSERT (((UINTN) String & BIT0) == 0); + ASSERT (((UINTN)String & BIT0) == 0); // // 1. None of String or Guid shall be a null pointer. @@ -1335,49 +1363,53 @@ StrToGuid ( // // Get aabbccdd in big-endian. // - Status = StrHexToBytes (String, 2 * sizeof (LocalGuid.Data1), (UINT8 *) &LocalGuid.Data1, sizeof (LocalGuid.Data1)); - if (RETURN_ERROR (Status) || String[2 * sizeof (LocalGuid.Data1)] != L'-') { + Status = StrHexToBytes (String, 2 * sizeof (LocalGuid.Data1), (UINT8 *)&LocalGuid.Data1, sizeof (LocalGuid.Data1)); + if (RETURN_ERROR (Status) || (String[2 * sizeof (LocalGuid.Data1)] != L'-')) { return RETURN_UNSUPPORTED; } + // // Convert big-endian to little-endian. // LocalGuid.Data1 = SwapBytes32 (LocalGuid.Data1); - String += 2 * sizeof (LocalGuid.Data1) + 1; + String += 2 * sizeof (LocalGuid.Data1) + 1; // // Get eeff in big-endian. // - Status = StrHexToBytes (String, 2 * sizeof (LocalGuid.Data2), (UINT8 *) &LocalGuid.Data2, sizeof (LocalGuid.Data2)); - if (RETURN_ERROR (Status) || String[2 * sizeof (LocalGuid.Data2)] != L'-') { + Status = StrHexToBytes (String, 2 * sizeof (LocalGuid.Data2), (UINT8 *)&LocalGuid.Data2, sizeof (LocalGuid.Data2)); + if (RETURN_ERROR (Status) || (String[2 * sizeof (LocalGuid.Data2)] != L'-')) { return RETURN_UNSUPPORTED; } + // // Convert big-endian to little-endian. // LocalGuid.Data2 = SwapBytes16 (LocalGuid.Data2); - String += 2 * sizeof (LocalGuid.Data2) + 1; + String += 2 * sizeof (LocalGuid.Data2) + 1; // // Get gghh in big-endian. // - Status = StrHexToBytes (String, 2 * sizeof (LocalGuid.Data3), (UINT8 *) &LocalGuid.Data3, sizeof (LocalGuid.Data3)); - if (RETURN_ERROR (Status) || String[2 * sizeof (LocalGuid.Data3)] != L'-') { + Status = StrHexToBytes (String, 2 * sizeof (LocalGuid.Data3), (UINT8 *)&LocalGuid.Data3, sizeof (LocalGuid.Data3)); + if (RETURN_ERROR (Status) || (String[2 * sizeof (LocalGuid.Data3)] != L'-')) { return RETURN_UNSUPPORTED; } + // // Convert big-endian to little-endian. // LocalGuid.Data3 = SwapBytes16 (LocalGuid.Data3); - String += 2 * sizeof (LocalGuid.Data3) + 1; + String += 2 * sizeof (LocalGuid.Data3) + 1; // // Get iijj. // Status = StrHexToBytes (String, 2 * 2, &LocalGuid.Data4[0], 2); - if (RETURN_ERROR (Status) || String[2 * 2] != L'-') { + if (RETURN_ERROR (Status) || (String[2 * 2] != L'-')) { return RETURN_UNSUPPORTED; } + String += 2 * 2 + 1; // @@ -1426,9 +1458,9 @@ StrToGuid ( **/ INTN StrnCmp ( - CONST CHAR16 *FirstString, - CONST CHAR16 *SecondString, - UINTN Length + CONST CHAR16 *FirstString, + CONST CHAR16 *SecondString, + UINTN Length ) { if (Length == 0) { @@ -1445,7 +1477,8 @@ StrnCmp ( while ((*FirstString != L'\0') && (*SecondString != L'\0') && (*FirstString == *SecondString) && - (Length > 1)) { + (Length > 1)) + { FirstString++; SecondString++; Length--; @@ -1456,8 +1489,8 @@ StrnCmp ( VOID * AllocateCopyPool ( - UINTN AllocationSize, - CONST VOID *Buffer + UINTN AllocationSize, + CONST VOID *Buffer ) { return InternalAllocateCopyPool (AllocationSize, Buffer); @@ -1465,8 +1498,8 @@ AllocateCopyPool ( INTN StrCmp ( - CONST CHAR16 *FirstString, - CONST CHAR16 *SecondString + CONST CHAR16 *FirstString, + CONST CHAR16 *SecondString ) { // @@ -1479,12 +1512,13 @@ StrCmp ( FirstString++; SecondString++; } + return *FirstString - *SecondString; } UINT64 SwapBytes64 ( - UINT64 Value + UINT64 Value ) { return InternalMathSwapBytes64 (Value); @@ -1492,37 +1526,37 @@ SwapBytes64 ( UINT64 InternalMathSwapBytes64 ( - UINT64 Operand + UINT64 Operand ) { UINT64 LowerBytes; UINT64 HigherBytes; - LowerBytes = (UINT64) SwapBytes32 ((UINT32) Operand); - HigherBytes = (UINT64) SwapBytes32 ((UINT32) (Operand >> 32)); + LowerBytes = (UINT64)SwapBytes32 ((UINT32)Operand); + HigherBytes = (UINT64)SwapBytes32 ((UINT32)(Operand >> 32)); return (LowerBytes << 32 | HigherBytes); } RETURN_STATUS StrToIpv4Address ( - CONST CHAR16 *String, - CHAR16 **EndPointer, - EFI_IPv4_ADDRESS *Address, - UINT8 *PrefixLength + CONST CHAR16 *String, + CHAR16 **EndPointer, + EFI_IPv4_ADDRESS *Address, + UINT8 *PrefixLength ) { - RETURN_STATUS Status; - UINTN AddressIndex; - UINT64 Uint64; - EFI_IPv4_ADDRESS LocalAddress; - UINT8 LocalPrefixLength; - CHAR16 *Pointer; + RETURN_STATUS Status; + UINTN AddressIndex; + UINT64 Uint64; + EFI_IPv4_ADDRESS LocalAddress; + UINT8 LocalPrefixLength; + CHAR16 *Pointer; - LocalPrefixLength = MAX_UINT8; + LocalPrefixLength = MAX_UINT8; LocalAddress.Addr[0] = 0; - ASSERT (((UINTN) String & BIT0) == 0); + ASSERT (((UINTN)String & BIT0) == 0); // // 1. None of String or Guid shall be a null pointer. @@ -1530,7 +1564,7 @@ StrToIpv4Address ( SAFE_STRING_CONSTRAINT_CHECK ((String != NULL), RETURN_INVALID_PARAMETER); SAFE_STRING_CONSTRAINT_CHECK ((Address != NULL), RETURN_INVALID_PARAMETER); - for (Pointer = (CHAR16 *) String, AddressIndex = 0; AddressIndex < ARRAY_SIZE (Address->Addr) + 1;) { + for (Pointer = (CHAR16 *)String, AddressIndex = 0; AddressIndex < ARRAY_SIZE (Address->Addr) + 1;) { if (!InternalIsDecimalDigitCharacter (*Pointer)) { // // D or P contains invalid characters. @@ -1541,10 +1575,11 @@ StrToIpv4Address ( // // Get D or P. // - Status = StrDecimalToUint64S ((CONST CHAR16 *) Pointer, &Pointer, &Uint64); + Status = StrDecimalToUint64S ((CONST CHAR16 *)Pointer, &Pointer, &Uint64); if (RETURN_ERROR (Status)) { return RETURN_UNSUPPORTED; } + if (AddressIndex == ARRAY_SIZE (Address->Addr)) { // // It's P. @@ -1552,7 +1587,8 @@ StrToIpv4Address ( if (Uint64 > 32) { return RETURN_UNSUPPORTED; } - LocalPrefixLength = (UINT8) Uint64; + + LocalPrefixLength = (UINT8)Uint64; } else { // // It's D. @@ -1560,7 +1596,8 @@ StrToIpv4Address ( if (Uint64 > MAX_UINT8) { return RETURN_UNSUPPORTED; } - LocalAddress.Addr[AddressIndex] = (UINT8) Uint64; + + LocalAddress.Addr[AddressIndex] = (UINT8)Uint64; AddressIndex++; } @@ -1600,6 +1637,7 @@ StrToIpv4Address ( if (PrefixLength != NULL) { *PrefixLength = LocalPrefixLength; } + if (EndPointer != NULL) { *EndPointer = Pointer; } @@ -1609,27 +1647,27 @@ StrToIpv4Address ( RETURN_STATUS StrToIpv6Address ( - CONST CHAR16 *String, - CHAR16 **EndPointer, - EFI_IPv6_ADDRESS *Address, - UINT8 *PrefixLength + CONST CHAR16 *String, + CHAR16 **EndPointer, + EFI_IPv6_ADDRESS *Address, + UINT8 *PrefixLength ) { - RETURN_STATUS Status; - UINTN AddressIndex; - UINT64 Uint64; - EFI_IPv6_ADDRESS LocalAddress; - UINT8 LocalPrefixLength; - CONST CHAR16 *Pointer; - CHAR16 *End; - UINTN CompressStart; - BOOLEAN ExpectPrefix; + RETURN_STATUS Status; + UINTN AddressIndex; + UINT64 Uint64; + EFI_IPv6_ADDRESS LocalAddress; + UINT8 LocalPrefixLength; + CONST CHAR16 *Pointer; + CHAR16 *End; + UINTN CompressStart; + BOOLEAN ExpectPrefix; LocalPrefixLength = MAX_UINT8; CompressStart = ARRAY_SIZE (Address->Addr); ExpectPrefix = FALSE; - ASSERT (((UINTN) String & BIT0) == 0); + ASSERT (((UINTN)String & BIT0) == 0); // // 1. None of String or Guid shall be a null pointer. @@ -1657,7 +1695,7 @@ StrToIpv6Address ( return RETURN_UNSUPPORTED; } - if (CompressStart != ARRAY_SIZE (Address->Addr) || AddressIndex == ARRAY_SIZE (Address->Addr)) { + if ((CompressStart != ARRAY_SIZE (Address->Addr)) || (AddressIndex == ARRAY_SIZE (Address->Addr))) { // // "::" can only appear once. // "::" can only appear when address is not full length. @@ -1677,6 +1715,7 @@ StrToIpv6Address ( // return RETURN_UNSUPPORTED; } + Pointer++; } } @@ -1699,33 +1738,35 @@ StrToIpv6Address ( // Get X. // Status = StrHexToUint64S (Pointer, &End, &Uint64); - if (RETURN_ERROR (Status) || End - Pointer > 4) { + if (RETURN_ERROR (Status) || (End - Pointer > 4)) { // // Number of hexadecimal digit characters is no more than 4. // return RETURN_UNSUPPORTED; } + Pointer = End; // // Uint64 won't exceed MAX_UINT16 if number of hexadecimal digit characters is no more than 4. // ASSERT (AddressIndex + 1 < ARRAY_SIZE (Address->Addr)); - LocalAddress.Addr[AddressIndex] = (UINT8) ((UINT16) Uint64 >> 8); - LocalAddress.Addr[AddressIndex + 1] = (UINT8) Uint64; - AddressIndex += 2; + LocalAddress.Addr[AddressIndex] = (UINT8)((UINT16)Uint64 >> 8); + LocalAddress.Addr[AddressIndex + 1] = (UINT8)Uint64; + AddressIndex += 2; } else { // // Get P, then exit the loop. // Status = StrDecimalToUint64S (Pointer, &End, &Uint64); - if (RETURN_ERROR (Status) || End == Pointer || Uint64 > 128) { + if (RETURN_ERROR (Status) || (End == Pointer) || (Uint64 > 128)) { // // Prefix length should not exceed 128. // return RETURN_UNSUPPORTED; } - LocalPrefixLength = (UINT8) Uint64; - Pointer = End; + + LocalPrefixLength = (UINT8)Uint64; + Pointer = End; break; } } @@ -1748,21 +1789,24 @@ StrToIpv6Address ( // break; } + Pointer++; } - if ((AddressIndex == ARRAY_SIZE (Address->Addr) && CompressStart != ARRAY_SIZE (Address->Addr)) || - (AddressIndex != ARRAY_SIZE (Address->Addr) && CompressStart == ARRAY_SIZE (Address->Addr)) - ) { + if (((AddressIndex == ARRAY_SIZE (Address->Addr)) && (CompressStart != ARRAY_SIZE (Address->Addr))) || + ((AddressIndex != ARRAY_SIZE (Address->Addr)) && (CompressStart == ARRAY_SIZE (Address->Addr))) + ) + { // // Full length of address shall not have compressing zeros. // Non-full length of address shall have compressing zeros. // return RETURN_UNSUPPORTED; } + memcpy (&Address->Addr[0], &LocalAddress.Addr[0], CompressStart); if (AddressIndex > CompressStart) { - memset (&Address->Addr[CompressStart], 0, ARRAY_SIZE (Address->Addr) - AddressIndex); + memset (&Address->Addr[CompressStart], 0, ARRAY_SIZE (Address->Addr) - AddressIndex); memcpy ( &Address->Addr[CompressStart + ARRAY_SIZE (Address->Addr) - AddressIndex], &LocalAddress.Addr[CompressStart], @@ -1773,24 +1817,24 @@ StrToIpv6Address ( if (PrefixLength != NULL) { *PrefixLength = LocalPrefixLength; } + if (EndPointer != NULL) { - *EndPointer = (CHAR16 *) Pointer; + *EndPointer = (CHAR16 *)Pointer; } return RETURN_SUCCESS; } - RETURN_STATUS UnicodeStrToAsciiStrS ( - CONST CHAR16 *Source, - CHAR8 *Destination, - UINTN DestMax + CONST CHAR16 *Source, + CHAR8 *Destination, + UINTN DestMax ) { - UINTN SourceLen; + UINTN SourceLen; - ASSERT (((UINTN) Source & BIT0) == 0); + ASSERT (((UINTN)Source & BIT0) == 0); // // 1. Neither Destination nor Source shall be a null pointer. @@ -1804,6 +1848,7 @@ UnicodeStrToAsciiStrS ( if (ASCII_RSIZE_MAX != 0) { SAFE_STRING_CONSTRAINT_CHECK ((DestMax <= ASCII_RSIZE_MAX), RETURN_INVALID_PARAMETER); } + if (RSIZE_MAX != 0) { SAFE_STRING_CONSTRAINT_CHECK ((DestMax <= RSIZE_MAX), RETURN_INVALID_PARAMETER); } @@ -1822,7 +1867,7 @@ UnicodeStrToAsciiStrS ( // // 5. Copying shall not take place between objects that overlap. // - SAFE_STRING_CONSTRAINT_CHECK (!InternalSafeStringIsOverlap (Destination, DestMax, (VOID *)Source, (SourceLen + 1) * sizeof(CHAR16)), RETURN_ACCESS_DENIED); + SAFE_STRING_CONSTRAINT_CHECK (!InternalSafeStringIsOverlap (Destination, DestMax, (VOID *)Source, (SourceLen + 1) * sizeof (CHAR16)), RETURN_ACCESS_DENIED); // // convert string @@ -1833,8 +1878,9 @@ UnicodeStrToAsciiStrS ( // non-zero value in the upper 8 bits, then ASSERT(). // ASSERT (*Source < 0x100); - *(Destination++) = (CHAR8) *(Source++); + *(Destination++) = (CHAR8)*(Source++); } + *Destination = '\0'; return RETURN_SUCCESS; @@ -1842,15 +1888,15 @@ UnicodeStrToAsciiStrS ( RETURN_STATUS StrCpyS ( - CHAR16 *Destination, - UINTN DestMax, - CONST CHAR16 *Source + CHAR16 *Destination, + UINTN DestMax, + CONST CHAR16 *Source ) { - UINTN SourceLen; + UINTN SourceLen; - ASSERT (((UINTN) Destination & BIT0) == 0); - ASSERT (((UINTN) Source & BIT0) == 0); + ASSERT (((UINTN)Destination & BIT0) == 0); + ASSERT (((UINTN)Source & BIT0) == 0); // // 1. Neither Destination nor Source shall be a null pointer. @@ -1888,6 +1934,7 @@ StrCpyS ( while (*Source != 0) { *(Destination++) = *(Source++); } + *Destination = 0; return RETURN_SUCCESS; @@ -1898,13 +1945,15 @@ AllocateZeroPool ( UINTN AllocationSize ) { - VOID * Memory; - Memory = malloc(AllocationSize); + VOID *Memory; + + Memory = malloc (AllocationSize); ASSERT (Memory != NULL); if (Memory == NULL) { - fprintf(stderr, "Not memory for malloc\n"); + fprintf (stderr, "Not memory for malloc\n"); } - memset(Memory, 0, AllocationSize); + + memset (Memory, 0, AllocationSize); return Memory; } @@ -1918,8 +1967,8 @@ AllocatePool ( UINT16 WriteUnaligned16 ( - UINT16 *Buffer, - UINT16 Value + UINT16 *Buffer, + UINT16 Value ) { ASSERT (Buffer != NULL); @@ -1929,13 +1978,14 @@ WriteUnaligned16 ( UINT16 ReadUnaligned16 ( - CONST UINT16 *Buffer + CONST UINT16 *Buffer ) { ASSERT (Buffer != NULL); return *Buffer; } + /** Return whether the integer string is a hex string. @@ -1947,23 +1997,24 @@ ReadUnaligned16 ( **/ BOOLEAN IsHexStr ( - CHAR16 *Str + CHAR16 *Str ) { // // skip preceding white space // while ((*Str != 0) && *Str == L' ') { - Str ++; + Str++; } + // // skip preceding zeros // while ((*Str != 0) && *Str == L'0') { - Str ++; + Str++; } - return (BOOLEAN) (*Str == L'x' || *Str == L'X'); + return (BOOLEAN)(*Str == L'x' || *Str == L'X'); } /** @@ -1977,7 +2028,7 @@ IsHexStr ( **/ UINTN Strtoi ( - CHAR16 *Str + CHAR16 *Str ) { if (IsHexStr (Str)) { @@ -1997,8 +2048,8 @@ Strtoi ( **/ VOID Strtoi64 ( - CHAR16 *Str, - UINT64 *Data + CHAR16 *Str, + UINT64 *Data ) { if (IsHexStr (Str)) { @@ -2018,16 +2069,17 @@ Strtoi64 ( **/ VOID StrToAscii ( - CHAR16 *Str, - CHAR8 **AsciiStr + CHAR16 *Str, + CHAR8 **AsciiStr ) { - CHAR8 *Dest; + CHAR8 *Dest; Dest = *AsciiStr; while (!IS_NULL (*Str)) { - *(Dest++) = (CHAR8) *(Str++); + *(Dest++) = (CHAR8)*(Str++); } + *Dest = 0; // @@ -2050,14 +2102,14 @@ StrToAscii ( **/ CHAR16 * SplitStr ( - CHAR16 **List, - CHAR16 Separator + CHAR16 **List, + CHAR16 Separator ) { CHAR16 *Str; CHAR16 *ReturnStr; - Str = *List; + Str = *List; ReturnStr = Str; if (IS_NULL (*Str)) { @@ -2071,6 +2123,7 @@ SplitStr ( if (*Str == Separator) { break; } + Str++; } @@ -2088,4 +2141,3 @@ SplitStr ( *List = Str; return ReturnStr; } - diff --git a/BaseTools/Source/C/Common/Crc32.c b/BaseTools/Source/C/Common/Crc32.c index 00cae948985d..1a702cab86ed 100644 --- a/BaseTools/Source/C/Common/Crc32.c +++ b/BaseTools/Source/C/Common/Crc32.c @@ -281,9 +281,9 @@ UINT32 mCrcTable[256] = { **/ EFI_STATUS CalculateCrc32 ( - IN UINT8 *Data, - IN UINTN DataSize, - IN OUT UINT32 *CrcOut + IN UINT8 *Data, + IN UINTN DataSize, + IN OUT UINT32 *CrcOut ) { UINT32 Crc; @@ -296,7 +296,7 @@ CalculateCrc32 ( Crc = 0xffffffff; for (Index = 0, Ptr = Data; Index < DataSize; Index++, Ptr++) { - Crc = (Crc >> 8) ^ mCrcTable[(UINT8) Crc ^ *Ptr]; + Crc = (Crc >> 8) ^ mCrcTable[(UINT8)Crc ^ *Ptr]; } *CrcOut = Crc ^ 0xffffffff; diff --git a/BaseTools/Source/C/Common/Decompress.c b/BaseTools/Source/C/Common/Decompress.c index a0f54c08342b..68745e8a0bd7 100644 --- a/BaseTools/Source/C/Common/Decompress.c +++ b/BaseTools/Source/C/Common/Decompress.c @@ -15,52 +15,52 @@ SPDX-License-Identifier: BSD-2-Clause-Patent // // Decompression algorithm begins here // -#define BITBUFSIZ 32 -#define MAXMATCH 256 -#define THRESHOLD 3 -#define CODE_BIT 16 -#define BAD_TABLE - 1 +#define BITBUFSIZ 32 +#define MAXMATCH 256 +#define THRESHOLD 3 +#define CODE_BIT 16 +#define BAD_TABLE - 1 // // C: Char&Len Set; P: Position Set; T: exTra Set // -#define NC (0xff + MAXMATCH + 2 - THRESHOLD) -#define CBIT 9 -#define EFIPBIT 4 -#define MAXPBIT 5 -#define TBIT 5 -#define MAXNP ((1U << MAXPBIT) - 1) -#define NT (CODE_BIT + 3) +#define NC (0xff + MAXMATCH + 2 - THRESHOLD) +#define CBIT 9 +#define EFIPBIT 4 +#define MAXPBIT 5 +#define TBIT 5 +#define MAXNP ((1U << MAXPBIT) - 1) +#define NT (CODE_BIT + 3) #if NT > MAXNP -#define NPT NT +#define NPT NT #else -#define NPT MAXNP +#define NPT MAXNP #endif typedef struct { - UINT8 *mSrcBase; // Starting address of compressed data - UINT8 *mDstBase; // Starting address of decompressed data - UINT32 mOutBuf; - UINT32 mInBuf; + UINT8 *mSrcBase; // Starting address of compressed data + UINT8 *mDstBase; // Starting address of decompressed data + UINT32 mOutBuf; + UINT32 mInBuf; - UINT16 mBitCount; - UINT32 mBitBuf; - UINT32 mSubBitBuf; - UINT16 mBlockSize; - UINT32 mCompSize; - UINT32 mOrigSize; + UINT16 mBitCount; + UINT32 mBitBuf; + UINT32 mSubBitBuf; + UINT16 mBlockSize; + UINT32 mCompSize; + UINT32 mOrigSize; - UINT16 mBadTableFlag; + UINT16 mBadTableFlag; - UINT16 mLeft[2 * NC - 1]; - UINT16 mRight[2 * NC - 1]; - UINT8 mCLen[NC]; - UINT8 mPTLen[NPT]; - UINT16 mCTable[4096]; - UINT16 mPTTable[256]; + UINT16 mLeft[2 * NC - 1]; + UINT16 mRight[2 * NC - 1]; + UINT8 mCLen[NC]; + UINT8 mPTLen[NPT]; + UINT16 mCTable[4096]; + UINT16 mPTTable[256]; } SCRATCH_DATA; -STATIC UINT16 mPbit = EFIPBIT; +STATIC UINT16 mPbit = EFIPBIT; /** Shift mBitBuf NumOfBits left. Read in NumOfBits of bits from source. @@ -75,33 +75,30 @@ FillBuf ( IN UINT16 NumOfBits ) { - Sd->mBitBuf = (UINT32) (((UINT64)Sd->mBitBuf) << NumOfBits); + Sd->mBitBuf = (UINT32)(((UINT64)Sd->mBitBuf) << NumOfBits); while (NumOfBits > Sd->mBitCount) { - - Sd->mBitBuf |= (UINT32) (((UINT64)Sd->mSubBitBuf) << (NumOfBits = (UINT16) (NumOfBits - Sd->mBitCount))); + Sd->mBitBuf |= (UINT32)(((UINT64)Sd->mSubBitBuf) << (NumOfBits = (UINT16)(NumOfBits - Sd->mBitCount))); if (Sd->mCompSize > 0) { // // Get 1 byte into SubBitBuf // Sd->mCompSize--; - Sd->mSubBitBuf = 0; - Sd->mSubBitBuf = Sd->mSrcBase[Sd->mInBuf++]; - Sd->mBitCount = 8; - + Sd->mSubBitBuf = 0; + Sd->mSubBitBuf = Sd->mSrcBase[Sd->mInBuf++]; + Sd->mBitCount = 8; } else { // // No more bits from the source, just pad zero bit. // - Sd->mSubBitBuf = 0; - Sd->mBitCount = 8; - + Sd->mSubBitBuf = 0; + Sd->mBitCount = 8; } } - Sd->mBitCount = (UINT16) (Sd->mBitCount - NumOfBits); - Sd->mBitBuf |= Sd->mSubBitBuf >> Sd->mBitCount; + Sd->mBitCount = (UINT16)(Sd->mBitCount - NumOfBits); + Sd->mBitBuf |= Sd->mSubBitBuf >> Sd->mBitCount; } /** @@ -123,7 +120,7 @@ GetBits ( { UINT32 OutBits; - OutBits = (UINT32) (Sd->mBitBuf >> (BITBUFSIZ - NumOfBits)); + OutBits = (UINT32)(Sd->mBitBuf >> (BITBUFSIZ - NumOfBits)); FillBuf (Sd, NumOfBits); @@ -172,76 +169,73 @@ MakeTable ( for (Index = 0; Index < NumOfChar; Index++) { if (BitLen[Index] > 16) { - return (UINT16) BAD_TABLE; + return (UINT16)BAD_TABLE; } + Count[BitLen[Index]]++; } Start[1] = 0; for (Index = 1; Index <= 16; Index++) { - Start[Index + 1] = (UINT16) (Start[Index] + (Count[Index] << (16 - Index))); + Start[Index + 1] = (UINT16)(Start[Index] + (Count[Index] << (16 - Index))); } if (Start[17] != 0) { /*(1U << 16)*/ - return (UINT16) BAD_TABLE; + return (UINT16)BAD_TABLE; } - JuBits = (UINT16) (16 - TableBits); + JuBits = (UINT16)(16 - TableBits); for (Index = 1; Index <= TableBits; Index++) { Start[Index] >>= JuBits; - Weight[Index] = (UINT16) (1U << (TableBits - Index)); + Weight[Index] = (UINT16)(1U << (TableBits - Index)); } while (Index <= 16) { - Weight[Index] = (UINT16) (1U << (16 - Index)); + Weight[Index] = (UINT16)(1U << (16 - Index)); Index++; } - Index = (UINT16) (Start[TableBits + 1] >> JuBits); + Index = (UINT16)(Start[TableBits + 1] >> JuBits); if (Index != 0) { - Index3 = (UINT16) (1U << TableBits); + Index3 = (UINT16)(1U << TableBits); while (Index != Index3) { Table[Index++] = 0; } } - Avail = NumOfChar; - Mask = (UINT16) (1U << (15 - TableBits)); - MaxTableLength = (UINT16) (1U << TableBits); + Avail = NumOfChar; + Mask = (UINT16)(1U << (15 - TableBits)); + MaxTableLength = (UINT16)(1U << TableBits); for (Char = 0; Char < NumOfChar; Char++) { - Len = BitLen[Char]; - if (Len == 0 || Len >= 17) { + if ((Len == 0) || (Len >= 17)) { continue; } - NextCode = (UINT16) (Start[Len] + Weight[Len]); + NextCode = (UINT16)(Start[Len] + Weight[Len]); if (Len <= TableBits) { - - if (Start[Len] >= NextCode || NextCode > MaxTableLength){ - return (UINT16) BAD_TABLE; + if ((Start[Len] >= NextCode) || (NextCode > MaxTableLength)) { + return (UINT16)BAD_TABLE; } for (Index = Start[Len]; Index < NextCode; Index++) { Table[Index] = Char; } - } else { - Index3 = Start[Len]; Pointer = &Table[Index3 >> JuBits]; - Index = (UINT16) (Len - TableBits); + Index = (UINT16)(Len - TableBits); while (Index != 0) { if (*Pointer == 0) { - Sd->mRight[Avail] = Sd->mLeft[Avail] = 0; - *Pointer = Avail++; + Sd->mRight[Avail] = Sd->mLeft[Avail] = 0; + *Pointer = Avail++; } if (Index3 & Mask) { @@ -255,11 +249,11 @@ MakeTable ( } *Pointer = Char; - } Start[Len] = NextCode; } + // // Succeeds // @@ -289,7 +283,6 @@ DecodeP ( Mask = 1U << (BITBUFSIZ - 1 - 8); do { - if (Sd->mBitBuf & Mask) { Val = Sd->mRight[Val]; } else { @@ -299,6 +292,7 @@ DecodeP ( Mask >>= 1; } while (Val >= MAXNP); } + // // Advance what we have read // @@ -306,7 +300,7 @@ DecodeP ( Pos = Val; if (Val > 1) { - Pos = (UINT32) ((1U << (Val - 1)) + GetBits (Sd, (UINT16) (Val - 1))); + Pos = (UINT32)((1U << (Val - 1)) + GetBits (Sd, (UINT16)(Val - 1))); } return Pos; @@ -339,10 +333,10 @@ ReadPTLen ( assert (nn <= NPT); - Number = (UINT16) GetBits (Sd, nbit); + Number = (UINT16)GetBits (Sd, nbit); if (Number == 0) { - CharC = (UINT16) GetBits (Sd, nbit); + CharC = (UINT16)GetBits (Sd, nbit); for (Index = 0; Index < 256; Index++) { Sd->mPTTable[Index] = CharC; @@ -358,8 +352,7 @@ ReadPTLen ( Index = 0; while (Index < Number && Index < NPT) { - - CharC = (UINT16) (Sd->mBitBuf >> (BITBUFSIZ - 3)); + CharC = (UINT16)(Sd->mBitBuf >> (BITBUFSIZ - 3)); if (CharC == 7) { Mask = 1U << (BITBUFSIZ - 1 - 3); @@ -369,14 +362,14 @@ ReadPTLen ( } } - FillBuf (Sd, (UINT16) ((CharC < 7) ? 3 : CharC - 3)); + FillBuf (Sd, (UINT16)((CharC < 7) ? 3 : CharC - 3)); - Sd->mPTLen[Index++] = (UINT8) CharC; + Sd->mPTLen[Index++] = (UINT8)CharC; if (Index == Special) { - CharC = (UINT16) GetBits (Sd, 2); + CharC = (UINT16)GetBits (Sd, 2); CharC--; - while ((INT16) (CharC) >= 0 && Index < NPT) { + while ((INT16)(CharC) >= 0 && Index < NPT) { Sd->mPTLen[Index++] = 0; CharC--; } @@ -406,10 +399,10 @@ ReadCLen ( UINT16 Index; UINT32 Mask; - Number = (UINT16) GetBits (Sd, CBIT); + Number = (UINT16)GetBits (Sd, CBIT); if (Number == 0) { - CharC = (UINT16) GetBits (Sd, CBIT); + CharC = (UINT16)GetBits (Sd, CBIT); for (Index = 0; Index < NC; Index++) { Sd->mCLen[Index] = 0; @@ -419,18 +412,16 @@ ReadCLen ( Sd->mCTable[Index] = CharC; } - return ; + return; } Index = 0; while (Index < Number) { - CharC = Sd->mPTTable[Sd->mBitBuf >> (BITBUFSIZ - 8)]; if (CharC >= NT) { Mask = 1U << (BITBUFSIZ - 1 - 8); do { - if (Mask & Sd->mBitBuf) { CharC = Sd->mRight[CharC]; } else { @@ -438,34 +429,30 @@ ReadCLen ( } Mask >>= 1; - } while (CharC >= NT); } + // // Advance what we have read // FillBuf (Sd, Sd->mPTLen[CharC]); if (CharC <= 2) { - if (CharC == 0) { CharC = 1; } else if (CharC == 1) { - CharC = (UINT16) (GetBits (Sd, 4) + 3); + CharC = (UINT16)(GetBits (Sd, 4) + 3); } else if (CharC == 2) { - CharC = (UINT16) (GetBits (Sd, CBIT) + 20); + CharC = (UINT16)(GetBits (Sd, CBIT) + 20); } CharC--; - while ((INT16) (CharC) >= 0) { + while ((INT16)(CharC) >= 0) { Sd->mCLen[Index++] = 0; CharC--; } - } else { - - Sd->mCLen[Index++] = (UINT8) (CharC - 2); - + Sd->mCLen[Index++] = (UINT8)(CharC - 2); } } @@ -475,7 +462,7 @@ ReadCLen ( MakeTable (Sd, NC, Sd->mCLen, 12, Sd->mCTable); - return ; + return; } /** @@ -498,7 +485,7 @@ DecodeC ( // // Starting a new block // - Sd->mBlockSize = (UINT16) GetBits (Sd, 16); + Sd->mBlockSize = (UINT16)GetBits (Sd, 16); Sd->mBadTableFlag = ReadPTLen (Sd, NT, TBIT, 3); if (Sd->mBadTableFlag != 0) { return 0; @@ -506,7 +493,7 @@ DecodeC ( ReadCLen (Sd); - Sd->mBadTableFlag = ReadPTLen (Sd, MAXNP, mPbit, (UINT16) (-1)); + Sd->mBadTableFlag = ReadPTLen (Sd, MAXNP, mPbit, (UINT16)(-1)); if (Sd->mBadTableFlag != 0) { return 0; } @@ -528,6 +515,7 @@ DecodeC ( Mask >>= 1; } while (Index2 >= NC); } + // // Advance what we have read // @@ -551,58 +539,60 @@ Decode ( UINT32 DataIdx; UINT16 CharC; - BytesRemain = (UINT16) (-1); + BytesRemain = (UINT16)(-1); - DataIdx = 0; + DataIdx = 0; - for (;;) { + for ( ; ;) { CharC = DecodeC (Sd); if (Sd->mBadTableFlag != 0) { - return ; + return; } if (CharC < 256) { // // Process an Original character // - Sd->mDstBase[Sd->mOutBuf++] = (UINT8) CharC; + Sd->mDstBase[Sd->mOutBuf++] = (UINT8)CharC; if (Sd->mOutBuf >= Sd->mOrigSize) { - return ; + return; } - } else { // // Process a Pointer // - CharC = (UINT16) (CharC - (UINT8_MAX + 1 - THRESHOLD)); + CharC = (UINT16)(CharC - (UINT8_MAX + 1 - THRESHOLD)); BytesRemain = CharC; - DataIdx = Sd->mOutBuf - DecodeP (Sd) - 1; + DataIdx = Sd->mOutBuf - DecodeP (Sd) - 1; BytesRemain--; - while ((INT16) (BytesRemain) >= 0) { + while ((INT16)(BytesRemain) >= 0) { if (Sd->mOutBuf >= Sd->mOrigSize) { - return ; + return; } + if (DataIdx >= Sd->mOrigSize) { - Sd->mBadTableFlag = (UINT16) BAD_TABLE; - return ; + Sd->mBadTableFlag = (UINT16)BAD_TABLE; + return; } + Sd->mDstBase[Sd->mOutBuf++] = Sd->mDstBase[DataIdx++]; BytesRemain--; } + // // Once mOutBuf is fully filled, directly return // if (Sd->mOutBuf >= Sd->mOrigSize) { - return ; + return; } } } - return ; + return; } /** @@ -624,12 +614,12 @@ GetInfo ( OUT UINT32 *ScratchSize ) { - UINT8 *Src; - UINT32 CompSize; + UINT8 *Src; + UINT32 CompSize; - *ScratchSize = sizeof (SCRATCH_DATA); + *ScratchSize = sizeof (SCRATCH_DATA); - Src = Source; + Src = Source; if (SrcSize < 8) { return EFI_INVALID_PARAMETER; } @@ -637,7 +627,7 @@ GetInfo ( CompSize = Src[0] + (Src[1] << 8) + (Src[2] << 16) + (Src[3] << 24); *DstSize = Src[4] + (Src[5] << 8) + (Src[6] << 16) + (Src[7] << 24); - if (SrcSize < CompSize + 8 || (CompSize + 8) < 8) { + if ((SrcSize < CompSize + 8) || ((CompSize + 8) < 8)) { return EFI_INVALID_PARAMETER; } @@ -675,24 +665,24 @@ Decompress ( UINT8 *Src; UINT8 *Dst; - Status = EFI_SUCCESS; - Src = Source; - Dst = Destination; + Status = EFI_SUCCESS; + Src = Source; + Dst = Destination; if (ScratchSize < sizeof (SCRATCH_DATA)) { return EFI_INVALID_PARAMETER; } - Sd = (SCRATCH_DATA *) Scratch; + Sd = (SCRATCH_DATA *)Scratch; if (SrcSize < 8) { return EFI_INVALID_PARAMETER; } - CompSize = Src[0] + (Src[1] << 8) + (Src[2] << 16) + (Src[3] << 24); - OrigSize = Src[4] + (Src[5] << 8) + (Src[6] << 16) + (Src[7] << 24); + CompSize = Src[0] + (Src[1] << 8) + (Src[2] << 16) + (Src[3] << 24); + OrigSize = Src[4] + (Src[5] << 8) + (Src[6] << 16) + (Src[7] << 24); - if (SrcSize < CompSize + 8 || (CompSize + 8) < 8) { + if ((SrcSize < CompSize + 8) || ((CompSize + 8) < 8)) { return EFI_INVALID_PARAMETER; } @@ -703,7 +693,7 @@ Decompress ( Src = Src + 8; for (Index = 0; Index < sizeof (SCRATCH_DATA); Index++) { - ((UINT8 *) Sd)[Index] = 0; + ((UINT8 *)Sd)[Index] = 0; } Sd->mSrcBase = Src; @@ -833,63 +823,66 @@ EFI_STATUS Extract ( IN VOID *Source, IN UINT32 SrcSize, - OUT VOID **Destination, - OUT UINT32 *DstSize, + OUT VOID **Destination, + OUT UINT32 *DstSize, IN UINTN Algorithm ) { - VOID *Scratch; - UINT32 ScratchSize; - EFI_STATUS Status; + VOID *Scratch; + UINT32 ScratchSize; + EFI_STATUS Status; Scratch = NULL; Status = EFI_SUCCESS; switch (Algorithm) { - case 0: - *Destination = (VOID *)malloc(SrcSize); - if (*Destination != NULL) { - memcpy(*Destination, Source, SrcSize); - } else { - Status = EFI_OUT_OF_RESOURCES; - } - break; - case 1: - Status = EfiGetInfo(Source, SrcSize, DstSize, &ScratchSize); - if (Status == EFI_SUCCESS) { - Scratch = (VOID *)malloc(ScratchSize); - if (Scratch == NULL) { - return EFI_OUT_OF_RESOURCES; + case 0: + *Destination = (VOID *)malloc (SrcSize); + if (*Destination != NULL) { + memcpy (*Destination, Source, SrcSize); + } else { + Status = EFI_OUT_OF_RESOURCES; } - *Destination = (VOID *)malloc(*DstSize); - if (*Destination == NULL) { - free (Scratch); - return EFI_OUT_OF_RESOURCES; - } + break; + case 1: + Status = EfiGetInfo (Source, SrcSize, DstSize, &ScratchSize); + if (Status == EFI_SUCCESS) { + Scratch = (VOID *)malloc (ScratchSize); + if (Scratch == NULL) { + return EFI_OUT_OF_RESOURCES; + } + + *Destination = (VOID *)malloc (*DstSize); + if (*Destination == NULL) { + free (Scratch); + return EFI_OUT_OF_RESOURCES; + } - Status = EfiDecompress(Source, SrcSize, *Destination, *DstSize, Scratch, ScratchSize); - } - break; - case 2: - Status = TianoGetInfo(Source, SrcSize, DstSize, &ScratchSize); - if (Status == EFI_SUCCESS) { - Scratch = (VOID *)malloc(ScratchSize); - if (Scratch == NULL) { - return EFI_OUT_OF_RESOURCES; + Status = EfiDecompress (Source, SrcSize, *Destination, *DstSize, Scratch, ScratchSize); } - *Destination = (VOID *)malloc(*DstSize); - if (*Destination == NULL) { - free (Scratch); - return EFI_OUT_OF_RESOURCES; + break; + case 2: + Status = TianoGetInfo (Source, SrcSize, DstSize, &ScratchSize); + if (Status == EFI_SUCCESS) { + Scratch = (VOID *)malloc (ScratchSize); + if (Scratch == NULL) { + return EFI_OUT_OF_RESOURCES; + } + + *Destination = (VOID *)malloc (*DstSize); + if (*Destination == NULL) { + free (Scratch); + return EFI_OUT_OF_RESOURCES; + } + + Status = TianoDecompress (Source, SrcSize, *Destination, *DstSize, Scratch, ScratchSize); } - Status = TianoDecompress(Source, SrcSize, *Destination, *DstSize, Scratch, ScratchSize); - } - break; - default: - Status = EFI_INVALID_PARAMETER; + break; + default: + Status = EFI_INVALID_PARAMETER; } if (Scratch != NULL) { @@ -898,5 +891,3 @@ Extract ( return Status; } - - diff --git a/BaseTools/Source/C/Common/EfiCompress.c b/BaseTools/Source/C/Common/EfiCompress.c index 0db958b8535a..badcc4d83972 100644 --- a/BaseTools/Source/C/Common/EfiCompress.c +++ b/BaseTools/Source/C/Common/EfiCompress.c @@ -11,42 +11,41 @@ SPDX-License-Identifier: BSD-2-Clause-Patent #include "Compress.h" - // // Macro Definitions // #undef UINT8_MAX -typedef INT16 NODE; -#define UINT8_MAX 0xff -#define UINT8_BIT 8 -#define THRESHOLD 3 -#define INIT_CRC 0 -#define WNDBIT 13 -#define WNDSIZ (1U << WNDBIT) -#define MAXMATCH 256 -#define PERC_FLAG 0x8000U -#define CODE_BIT 16 -#define NIL 0 -#define MAX_HASH_VAL (3 * WNDSIZ + (WNDSIZ / 512 + 1) * UINT8_MAX) -#define HASH(p, c) ((p) + ((c) << (WNDBIT - 9)) + WNDSIZ * 2) -#define CRCPOLY 0xA001 -#define UPDATE_CRC(c) mCrc = mCrcTable[(mCrc ^ (c)) & 0xFF] ^ (mCrc >> UINT8_BIT) +typedef INT16 NODE; +#define UINT8_MAX 0xff +#define UINT8_BIT 8 +#define THRESHOLD 3 +#define INIT_CRC 0 +#define WNDBIT 13 +#define WNDSIZ (1U << WNDBIT) +#define MAXMATCH 256 +#define PERC_FLAG 0x8000U +#define CODE_BIT 16 +#define NIL 0 +#define MAX_HASH_VAL (3 * WNDSIZ + (WNDSIZ / 512 + 1) * UINT8_MAX) +#define HASH(p, c) ((p) + ((c) << (WNDBIT - 9)) + WNDSIZ * 2) +#define CRCPOLY 0xA001 +#define UPDATE_CRC(c) mCrc = mCrcTable[(mCrc ^ (c)) & 0xFF] ^ (mCrc >> UINT8_BIT) // // C: the Char&Len Set; P: the Position Set; T: the exTra Set // -#define NC (UINT8_MAX + MAXMATCH + 2 - THRESHOLD) -#define CBIT 9 -#define NP (WNDBIT + 1) -#define PBIT 4 -#define NT (CODE_BIT + 3) -#define TBIT 5 +#define NC (UINT8_MAX + MAXMATCH + 2 - THRESHOLD) +#define CBIT 9 +#define NP (WNDBIT + 1) +#define PBIT 4 +#define NT (CODE_BIT + 3) +#define TBIT 5 #if NT > NP - #define NPT NT +#define NPT NT #else - #define NPT NP +#define NPT NP #endif // @@ -55,8 +54,8 @@ typedef INT16 NODE; STATIC VOID -PutDword( - IN UINT32 Data +PutDword ( + IN UINT32 Data ); STATIC @@ -77,22 +76,22 @@ InitSlide ( STATIC NODE Child ( - IN NODE q, - IN UINT8 c + IN NODE q, + IN UINT8 c ); STATIC VOID MakeChild ( - IN NODE q, - IN UINT8 c, - IN NODE r + IN NODE q, + IN UINT8 c, + IN NODE r ); STATIC VOID Split ( - IN NODE Old + IN NODE Old ); STATIC @@ -123,9 +122,9 @@ CountTFreq ( STATIC VOID WritePTLen ( - IN INT32 n, - IN INT32 nbit, - IN INT32 Special + IN INT32 n, + IN INT32 nbit, + IN INT32 Special ); STATIC @@ -136,13 +135,13 @@ WriteCLen ( STATIC VOID EncodeC ( - IN INT32 c + IN INT32 c ); STATIC VOID EncodeP ( - IN UINT32 p + IN UINT32 p ); STATIC @@ -153,8 +152,8 @@ SendBlock ( STATIC VOID Output ( - IN UINT32 c, - IN UINT32 p + IN UINT32 c, + IN UINT32 p ); STATIC @@ -175,15 +174,15 @@ MakeCrcTable ( STATIC VOID PutBits ( - IN INT32 n, - IN UINT32 x + IN INT32 n, + IN UINT32 x ); STATIC INT32 FreadCrc ( - OUT UINT8 *p, - IN INT32 n + OUT UINT8 *p, + IN INT32 n ); STATIC @@ -194,27 +193,27 @@ InitPutBits ( STATIC VOID CountLen ( - IN INT32 i + IN INT32 i ); STATIC VOID MakeLen ( - IN INT32 Root + IN INT32 Root ); STATIC VOID DownHeap ( - IN INT32 i + IN INT32 i ); STATIC VOID MakeCode ( - IN INT32 n, - IN UINT8 Len[], - OUT UINT16 Code[] + IN INT32 n, + IN UINT8 Len[], + OUT UINT16 Code[] ); STATIC @@ -226,25 +225,23 @@ MakeTree ( OUT UINT16 CodeParm[] ); - // // Global Variables // STATIC UINT8 *mSrc, *mDst, *mSrcUpperLimit, *mDstUpperLimit; -STATIC UINT8 *mLevel, *mText, *mChildCount, *mBuf, mCLen[NC], mPTLen[NPT], *mLen; -STATIC INT16 mHeap[NC + 1]; -STATIC INT32 mRemainder, mMatchLen, mBitCount, mHeapSize, mN; -STATIC UINT32 mBufSiz = 0, mOutputPos, mOutputMask, mSubBitBuf, mCrc; -STATIC UINT32 mCompSize, mOrigSize; +STATIC UINT8 *mLevel, *mText, *mChildCount, *mBuf, mCLen[NC], mPTLen[NPT], *mLen; +STATIC INT16 mHeap[NC + 1]; +STATIC INT32 mRemainder, mMatchLen, mBitCount, mHeapSize, mN; +STATIC UINT32 mBufSiz = 0, mOutputPos, mOutputMask, mSubBitBuf, mCrc; +STATIC UINT32 mCompSize, mOrigSize; -STATIC UINT16 *mFreq, *mSortPtr, mLenCnt[17], mLeft[2 * NC - 1], mRight[2 * NC - 1], - mCrcTable[UINT8_MAX + 1], mCFreq[2 * NC - 1],mCCode[NC], - mPFreq[2 * NP - 1], mPTCode[NPT], mTFreq[2 * NT - 1]; - -STATIC NODE mPos, mMatchPos, mAvail, *mPosition, *mParent, *mPrev, *mNext = NULL; +STATIC UINT16 *mFreq, *mSortPtr, mLenCnt[17], mLeft[2 * NC - 1], mRight[2 * NC - 1], + mCrcTable[UINT8_MAX + 1], mCFreq[2 * NC - 1], mCCode[NC], + mPFreq[2 * NP - 1], mPTCode[NPT], mTFreq[2 * NT - 1]; +STATIC NODE mPos, mMatchPos, mAvail, *mPosition, *mParent, *mPrev, *mNext = NULL; // // functions @@ -272,13 +269,13 @@ EfiCompress ( IN OUT UINT32 *DstSize ) { - EFI_STATUS Status = EFI_SUCCESS; + EFI_STATUS Status = EFI_SUCCESS; // // Initializations // - mBufSiz = 0; - mBuf = NULL; + mBufSiz = 0; + mBuf = NULL; mText = NULL; mLevel = NULL; mChildCount = NULL; @@ -287,25 +284,24 @@ EfiCompress ( mPrev = NULL; mNext = NULL; - - mSrc = SrcBuffer; + mSrc = SrcBuffer; mSrcUpperLimit = mSrc + SrcSize; - mDst = DstBuffer; + mDst = DstBuffer; mDstUpperLimit = mDst + *DstSize; - PutDword(0L); - PutDword(0L); + PutDword (0L); + PutDword (0L); MakeCrcTable (); mOrigSize = mCompSize = 0; - mCrc = INIT_CRC; + mCrc = INIT_CRC; // // Compress it // - Status = Encode(); + Status = Encode (); if (EFI_ERROR (Status)) { return EFI_OUT_OF_RESOURCES; } @@ -321,8 +317,8 @@ EfiCompress ( // Fill in compressed size and original size // mDst = DstBuffer; - PutDword(mCompSize+1); - PutDword(mOrigSize); + PutDword (mCompSize+1); + PutDword (mOrigSize); // // Return @@ -335,7 +331,6 @@ EfiCompress ( *DstSize = mCompSize + 1 + 8; return EFI_SUCCESS; } - } /** @@ -345,12 +340,12 @@ EfiCompress ( **/ STATIC VOID -PutDword( - IN UINT32 Data +PutDword ( + IN UINT32 Data ) { if (mDst < mDstUpperLimit) { - *mDst++ = (UINT8)(((UINT8)(Data )) & 0xff); + *mDst++ = (UINT8)(((UINT8)(Data)) & 0xff); } if (mDst < mDstUpperLimit) { @@ -374,36 +369,40 @@ PutDword( **/ STATIC EFI_STATUS -AllocateMemory () +AllocateMemory ( + ) { - UINT32 i; + UINT32 i; - mText = malloc (WNDSIZ * 2 + MAXMATCH); + mText = malloc (WNDSIZ * 2 + MAXMATCH); if (mText == NULL) { return EFI_OUT_OF_RESOURCES; } - for (i = 0 ; i < WNDSIZ * 2 + MAXMATCH; i ++) { + + for (i = 0; i < WNDSIZ * 2 + MAXMATCH; i++) { mText[i] = 0; } - mLevel = malloc ((WNDSIZ + UINT8_MAX + 1) * sizeof(*mLevel)); - mChildCount = malloc ((WNDSIZ + UINT8_MAX + 1) * sizeof(*mChildCount)); - mPosition = malloc ((WNDSIZ + UINT8_MAX + 1) * sizeof(*mPosition)); - mParent = malloc (WNDSIZ * 2 * sizeof(*mParent)); - mPrev = malloc (WNDSIZ * 2 * sizeof(*mPrev)); - mNext = malloc ((MAX_HASH_VAL + 1) * sizeof(*mNext)); - if (mLevel == NULL || mChildCount == NULL || mPosition == NULL || - mParent == NULL || mPrev == NULL || mNext == NULL) { + mLevel = malloc ((WNDSIZ + UINT8_MAX + 1) * sizeof (*mLevel)); + mChildCount = malloc ((WNDSIZ + UINT8_MAX + 1) * sizeof (*mChildCount)); + mPosition = malloc ((WNDSIZ + UINT8_MAX + 1) * sizeof (*mPosition)); + mParent = malloc (WNDSIZ * 2 * sizeof (*mParent)); + mPrev = malloc (WNDSIZ * 2 * sizeof (*mPrev)); + mNext = malloc ((MAX_HASH_VAL + 1) * sizeof (*mNext)); + if ((mLevel == NULL) || (mChildCount == NULL) || (mPosition == NULL) || + (mParent == NULL) || (mPrev == NULL) || (mNext == NULL)) + { return EFI_OUT_OF_RESOURCES; } mBufSiz = 16 * 1024U; - while ((mBuf = malloc(mBufSiz)) == NULL) { + while ((mBuf = malloc (mBufSiz)) == NULL) { mBufSiz = (mBufSiz / 10U) * 9U; if (mBufSiz < 4 * 1024U) { return EFI_OUT_OF_RESOURCES; } } + mBuf[0] = 0; return EFI_SUCCESS; @@ -413,7 +412,8 @@ AllocateMemory () Called when compression is completed to free memory previously allocated. **/ VOID -FreeMemory () +FreeMemory ( + ) { if (mText) { free (mText); @@ -455,17 +455,20 @@ FreeMemory () **/ STATIC VOID -InitSlide () +InitSlide ( + ) { - NODE i; + NODE i; for (i = WNDSIZ; i <= WNDSIZ + UINT8_MAX; i++) { - mLevel[i] = 1; + mLevel[i] = 1; mPosition[i] = NIL; /* sentinel */ } + for (i = WNDSIZ; i < WNDSIZ * 2; i++) { mParent[i] = NIL; } + mAvail = 1; for (i = 1; i < WNDSIZ - 1; i++) { mNext[i] = (NODE)(i + 1); @@ -488,13 +491,13 @@ InitSlide () STATIC NODE Child ( - IN NODE q, - IN UINT8 c + IN NODE q, + IN UINT8 c ) { - NODE r; + NODE r; - r = mNext[HASH(q, c)]; + r = mNext[HASH (q, c)]; mParent[NIL] = q; /* sentinel */ while (mParent[r] != q) { r = mNext[r]; @@ -513,19 +516,19 @@ Child ( STATIC VOID MakeChild ( - IN NODE q, - IN UINT8 c, - IN NODE r + IN NODE q, + IN UINT8 c, + IN NODE r ) { - NODE h, t; + NODE h, t; - h = (NODE)HASH(q, c); - t = mNext[h]; - mNext[h] = r; - mNext[r] = t; - mPrev[t] = r; - mPrev[r] = h; + h = (NODE)HASH (q, c); + t = mNext[h]; + mNext[h] = r; + mNext[r] = t; + mPrev[t] = r; + mPrev[r] = h; mParent[r] = q; mChildCount[q]++; } @@ -538,25 +541,25 @@ MakeChild ( STATIC VOID Split ( - NODE Old + NODE Old ) { - NODE New, t; + NODE New, t; - New = mAvail; - mAvail = mNext[New]; + New = mAvail; + mAvail = mNext[New]; mChildCount[New] = 0; - t = mPrev[Old]; - mPrev[New] = t; - mNext[t] = New; - t = mNext[Old]; - mNext[New] = t; - mPrev[t] = New; - mParent[New] = mParent[Old]; - mLevel[New] = (UINT8)mMatchLen; - mPosition[New] = mPos; - MakeChild(New, mText[mMatchPos + mMatchLen], Old); - MakeChild(New, mText[mPos + mMatchLen], mPos); + t = mPrev[Old]; + mPrev[New] = t; + mNext[t] = New; + t = mNext[Old]; + mNext[New] = t; + mPrev[t] = New; + mParent[New] = mParent[Old]; + mLevel[New] = (UINT8)mMatchLen; + mPosition[New] = mPos; + MakeChild (New, mText[mMatchPos + mMatchLen], Old); + MakeChild (New, mText[mPos + mMatchLen], mPos); } /** @@ -564,13 +567,13 @@ Split ( **/ STATIC VOID -InsertNode () +InsertNode ( + ) { - NODE q, r, j, t; - UINT8 c, *t1, *t2; + NODE q, r, j, t; + UINT8 c, *t1, *t2; if (mMatchLen >= 4) { - // // We have just got a long match, the target tree // can be located by MatchPos + 1. Traverse the tree @@ -584,30 +587,34 @@ InsertNode () while ((q = mParent[r]) == NIL) { r = mNext[r]; } + while (mLevel[q] >= mMatchLen) { - r = q; q = mParent[q]; + r = q; + q = mParent[q]; } + t = q; while (mPosition[t] < 0) { mPosition[t] = mPos; - t = mParent[t]; + t = mParent[t]; } + if (t < WNDSIZ) { mPosition[t] = (NODE)(mPos | PERC_FLAG); } } else { - // // Locate the target tree // q = (INT16)(mText[mPos] + WNDSIZ); c = mText[mPos + 1]; - if ((r = Child(q, c)) == NIL) { - MakeChild(q, c, mPos); + if ((r = Child (q, c)) == NIL) { + MakeChild (q, c, mPos); mMatchLen = 1; return; } + mMatchLen = 2; } @@ -619,51 +626,57 @@ InsertNode () for ( ; ; ) { if (r >= WNDSIZ) { - j = MAXMATCH; + j = MAXMATCH; mMatchPos = r; } else { - j = mLevel[r]; + j = mLevel[r]; mMatchPos = (NODE)(mPosition[r] & ~PERC_FLAG); } + if (mMatchPos >= mPos) { mMatchPos -= WNDSIZ; } + t1 = &mText[mPos + mMatchLen]; t2 = &mText[mMatchPos + mMatchLen]; while (mMatchLen < j) { if (*t1 != *t2) { - Split(r); + Split (r); return; } + mMatchLen++; t1++; t2++; } + if (mMatchLen >= MAXMATCH) { break; } + mPosition[r] = mPos; - q = r; - if ((r = Child(q, *t1)) == NIL) { - MakeChild(q, *t1, mPos); + q = r; + if ((r = Child (q, *t1)) == NIL) { + MakeChild (q, *t1, mPos); return; } + mMatchLen++; } - t = mPrev[r]; - mPrev[mPos] = t; - mNext[t] = mPos; - t = mNext[r]; - mNext[mPos] = t; - mPrev[t] = mPos; + + t = mPrev[r]; + mPrev[mPos] = t; + mNext[t] = mPos; + t = mNext[r]; + mNext[mPos] = t; + mPrev[t] = mPos; mParent[mPos] = q; - mParent[r] = NIL; + mParent[r] = NIL; // // Special usage of 'next' // mNext[r] = mPos; - } /** @@ -672,27 +685,30 @@ InsertNode () **/ STATIC VOID -DeleteNode () +DeleteNode ( + ) { - NODE q, r, s, t, u; + NODE q, r, s, t, u; if (mParent[mPos] == NIL) { return; } - r = mPrev[mPos]; - s = mNext[mPos]; - mNext[r] = s; - mPrev[s] = r; - r = mParent[mPos]; + r = mPrev[mPos]; + s = mNext[mPos]; + mNext[r] = s; + mPrev[s] = r; + r = mParent[mPos]; mParent[mPos] = NIL; - if (r >= WNDSIZ || --mChildCount[r] > 1) { + if ((r >= WNDSIZ) || (--mChildCount[r] > 1)) { return; } + t = (NODE)(mPosition[r] & ~PERC_FLAG); if (t >= mPos) { t -= WNDSIZ; } + s = t; q = mParent[r]; while ((u = mPosition[q]) & PERC_FLAG) { @@ -700,36 +716,42 @@ DeleteNode () if (u >= mPos) { u -= WNDSIZ; } + if (u > s) { s = u; } + mPosition[q] = (INT16)(s | WNDSIZ); - q = mParent[q]; + q = mParent[q]; } + if (q < WNDSIZ) { if (u >= mPos) { u -= WNDSIZ; } + if (u > s) { s = u; } + mPosition[q] = (INT16)(s | WNDSIZ | PERC_FLAG); } - s = Child(r, mText[t + mLevel[r]]); - t = mPrev[s]; - u = mNext[s]; - mNext[t] = u; - mPrev[u] = t; - t = mPrev[r]; - mNext[t] = s; - mPrev[s] = t; - t = mNext[r]; - mPrev[t] = s; - mNext[s] = t; + + s = Child (r, mText[t + mLevel[r]]); + t = mPrev[s]; + u = mNext[s]; + mNext[t] = u; + mPrev[u] = t; + t = mPrev[r]; + mNext[t] = s; + mPrev[s] = t; + t = mNext[r]; + mPrev[t] = s; + mNext[s] = t; mParent[s] = mParent[r]; mParent[r] = NIL; - mNext[r] = mAvail; - mAvail = r; + mNext[r] = mAvail; + mAvail = r; } /** @@ -738,19 +760,21 @@ DeleteNode () **/ STATIC VOID -GetNextMatch () +GetNextMatch ( + ) { - INT32 n; + INT32 n; mRemainder--; if (++mPos == WNDSIZ * 2) { - memmove(&mText[0], &mText[WNDSIZ], WNDSIZ + MAXMATCH); - n = FreadCrc(&mText[WNDSIZ + MAXMATCH], WNDSIZ); + memmove (&mText[0], &mText[WNDSIZ], WNDSIZ + MAXMATCH); + n = FreadCrc (&mText[WNDSIZ + MAXMATCH], WNDSIZ); mRemainder += n; - mPos = WNDSIZ; + mPos = WNDSIZ; } - DeleteNode(); - InsertNode(); + + DeleteNode (); + InsertNode (); } /** @@ -761,65 +785,68 @@ GetNextMatch () **/ STATIC EFI_STATUS -Encode () +Encode ( + ) { EFI_STATUS Status; INT32 LastMatchLen; NODE LastMatchPos; - Status = AllocateMemory(); - if (EFI_ERROR(Status)) { - FreeMemory(); + Status = AllocateMemory (); + if (EFI_ERROR (Status)) { + FreeMemory (); return Status; } - InitSlide(); + InitSlide (); - HufEncodeStart(); + HufEncodeStart (); - mRemainder = FreadCrc(&mText[WNDSIZ], WNDSIZ + MAXMATCH); + mRemainder = FreadCrc (&mText[WNDSIZ], WNDSIZ + MAXMATCH); mMatchLen = 0; - mPos = WNDSIZ; - InsertNode(); + mPos = WNDSIZ; + InsertNode (); if (mMatchLen > mRemainder) { mMatchLen = mRemainder; } + while (mRemainder > 0) { LastMatchLen = mMatchLen; LastMatchPos = mMatchPos; - GetNextMatch(); + GetNextMatch (); if (mMatchLen > mRemainder) { mMatchLen = mRemainder; } - if (mMatchLen > LastMatchLen || LastMatchLen < THRESHOLD) { - + if ((mMatchLen > LastMatchLen) || (LastMatchLen < THRESHOLD)) { // // Not enough benefits are gained by outputting a pointer, // so just output the original character // - Output(mText[mPos - 1], 0); + Output (mText[mPos - 1], 0); } else { - // // Outputting a pointer is beneficial enough, do it. // - Output(LastMatchLen + (UINT8_MAX + 1 - THRESHOLD), - (mPos - LastMatchPos - 2) & (WNDSIZ - 1)); + Output ( + LastMatchLen + (UINT8_MAX + 1 - THRESHOLD), + (mPos - LastMatchPos - 2) & (WNDSIZ - 1) + ); while (--LastMatchLen > 0) { - GetNextMatch(); + GetNextMatch (); } + if (mMatchLen > mRemainder) { mMatchLen = mRemainder; } } } - HufEncodeEnd(); - FreeMemory(); + HufEncodeEnd (); + FreeMemory (); return EFI_SUCCESS; } @@ -828,17 +855,20 @@ Encode () **/ STATIC VOID -CountTFreq () +CountTFreq ( + ) { - INT32 i, k, n, Count; + INT32 i, k, n, Count; for (i = 0; i < NT; i++) { mTFreq[i] = 0; } + n = NC; while (n > 0 && mCLen[n - 1] == 0) { n--; } + i = 0; while (i < n) { k = mCLen[i++]; @@ -848,6 +878,7 @@ CountTFreq () i++; Count++; } + if (Count <= 2) { mTFreq[0] = (UINT16)(mTFreq[0] + Count); } else if (Count <= 18) { @@ -874,30 +905,33 @@ CountTFreq () STATIC VOID WritePTLen ( - IN INT32 n, - IN INT32 nbit, - IN INT32 Special + IN INT32 n, + IN INT32 nbit, + IN INT32 Special ) { - INT32 i, k; + INT32 i, k; while (n > 0 && mPTLen[n - 1] == 0) { n--; } - PutBits(nbit, n); + + PutBits (nbit, n); i = 0; while (i < n) { k = mPTLen[i++]; if (k <= 6) { - PutBits(3, k); + PutBits (3, k); } else { - PutBits(k - 3, (1U << (k - 3)) - 2); + PutBits (k - 3, (1U << (k - 3)) - 2); } + if (i == Special) { while (i < 6 && mPTLen[i] == 0) { i++; } - PutBits(2, (i - 3) & 3); + + PutBits (2, (i - 3) & 3); } } } @@ -907,15 +941,17 @@ WritePTLen ( **/ STATIC VOID -WriteCLen () +WriteCLen ( + ) { - INT32 i, k, n, Count; + INT32 i, k, n, Count; n = NC; while (n > 0 && mCLen[n - 1] == 0) { n--; } - PutBits(CBIT, n); + + PutBits (CBIT, n); i = 0; while (i < n) { k = mCLen[i++]; @@ -925,23 +961,24 @@ WriteCLen () i++; Count++; } + if (Count <= 2) { for (k = 0; k < Count; k++) { - PutBits(mPTLen[0], mPTCode[0]); + PutBits (mPTLen[0], mPTCode[0]); } } else if (Count <= 18) { - PutBits(mPTLen[1], mPTCode[1]); - PutBits(4, Count - 3); + PutBits (mPTLen[1], mPTCode[1]); + PutBits (4, Count - 3); } else if (Count == 19) { - PutBits(mPTLen[0], mPTCode[0]); - PutBits(mPTLen[1], mPTCode[1]); - PutBits(4, 15); + PutBits (mPTLen[0], mPTCode[0]); + PutBits (mPTLen[1], mPTCode[1]); + PutBits (4, 15); } else { - PutBits(mPTLen[2], mPTCode[2]); - PutBits(CBIT, Count - 20); + PutBits (mPTLen[2], mPTCode[2]); + PutBits (CBIT, Count - 20); } } else { - PutBits(mPTLen[k + 2], mPTCode[k + 2]); + PutBits (mPTLen[k + 2], mPTCode[k + 2]); } } } @@ -949,19 +986,19 @@ WriteCLen () STATIC VOID EncodeC ( - IN INT32 c + IN INT32 c ) { - PutBits(mCLen[c], mCCode[c]); + PutBits (mCLen[c], mCCode[c]); } STATIC VOID EncodeP ( - IN UINT32 p + IN UINT32 p ) { - UINT32 c, q; + UINT32 c, q; c = 0; q = p; @@ -969,9 +1006,10 @@ EncodeP ( q >>= 1; c++; } - PutBits(mPTLen[c], mPTCode[c]); + + PutBits (mPTLen[c], mPTCode[c]); if (c > 1) { - PutBits(c - 1, p & (0xFFFFU >> (17 - c))); + PutBits (c - 1, p & (0xFFFFU >> (17 - c))); } } @@ -980,37 +1018,42 @@ EncodeP ( **/ STATIC VOID -SendBlock () +SendBlock ( + ) { - UINT32 i, k, Flags, Root, Pos, Size; + UINT32 i, k, Flags, Root, Pos, Size; + Flags = 0; - Root = MakeTree(NC, mCFreq, mCLen, mCCode); + Root = MakeTree (NC, mCFreq, mCLen, mCCode); Size = mCFreq[Root]; - PutBits(16, Size); + PutBits (16, Size); if (Root >= NC) { - CountTFreq(); - Root = MakeTree(NT, mTFreq, mPTLen, mPTCode); + CountTFreq (); + Root = MakeTree (NT, mTFreq, mPTLen, mPTCode); if (Root >= NT) { - WritePTLen(NT, TBIT, 3); + WritePTLen (NT, TBIT, 3); } else { - PutBits(TBIT, 0); - PutBits(TBIT, Root); + PutBits (TBIT, 0); + PutBits (TBIT, Root); } - WriteCLen(); + + WriteCLen (); } else { - PutBits(TBIT, 0); - PutBits(TBIT, 0); - PutBits(CBIT, 0); - PutBits(CBIT, Root); + PutBits (TBIT, 0); + PutBits (TBIT, 0); + PutBits (CBIT, 0); + PutBits (CBIT, Root); } - Root = MakeTree(NP, mPFreq, mPTLen, mPTCode); + + Root = MakeTree (NP, mPFreq, mPTLen, mPTCode); if (Root >= NP) { - WritePTLen(NP, PBIT, -1); + WritePTLen (NP, PBIT, -1); } else { - PutBits(PBIT, 0); - PutBits(PBIT, Root); + PutBits (PBIT, 0); + PutBits (PBIT, Root); } + Pos = 0; for (i = 0; i < Size; i++) { if (i % UINT8_BIT == 0) { @@ -1018,18 +1061,21 @@ SendBlock () } else { Flags <<= 1; } + if (Flags & (1U << (UINT8_BIT - 1))) { - EncodeC(mBuf[Pos++] + (1U << UINT8_BIT)); - k = mBuf[Pos++] << UINT8_BIT; + EncodeC (mBuf[Pos++] + (1U << UINT8_BIT)); + k = mBuf[Pos++] << UINT8_BIT; k += mBuf[Pos++]; - EncodeP(k); + EncodeP (k); } else { - EncodeC(mBuf[Pos++]); + EncodeC (mBuf[Pos++]); } } + for (i = 0; i < NC; i++) { mCFreq[i] = 0; } + for (i = 0; i < NP; i++) { mPFreq[i] = 0; } @@ -1044,73 +1090,80 @@ SendBlock () STATIC VOID Output ( - IN UINT32 c, - IN UINT32 p + IN UINT32 c, + IN UINT32 p ) { - STATIC UINT32 CPos; + STATIC UINT32 CPos; if ((mOutputMask >>= 1) == 0) { mOutputMask = 1U << (UINT8_BIT - 1); if (mOutputPos >= mBufSiz - 3 * UINT8_BIT) { - SendBlock(); + SendBlock (); mOutputPos = 0; } - CPos = mOutputPos++; + + CPos = mOutputPos++; mBuf[CPos] = 0; } - mBuf[mOutputPos++] = (UINT8) c; + + mBuf[mOutputPos++] = (UINT8)c; mCFreq[c]++; if (c >= (1U << UINT8_BIT)) { - mBuf[CPos] |= mOutputMask; + mBuf[CPos] |= mOutputMask; mBuf[mOutputPos++] = (UINT8)(p >> UINT8_BIT); - mBuf[mOutputPos++] = (UINT8) p; - c = 0; + mBuf[mOutputPos++] = (UINT8)p; + c = 0; while (p) { p >>= 1; c++; } + mPFreq[c]++; } } STATIC VOID -HufEncodeStart () +HufEncodeStart ( + ) { - INT32 i; + INT32 i; for (i = 0; i < NC; i++) { mCFreq[i] = 0; } + for (i = 0; i < NP; i++) { mPFreq[i] = 0; } + mOutputPos = mOutputMask = 0; - InitPutBits(); + InitPutBits (); return; } STATIC VOID -HufEncodeEnd () +HufEncodeEnd ( + ) { - SendBlock(); + SendBlock (); // // Flush remaining bits // - PutBits(UINT8_BIT - 1, 0); + PutBits (UINT8_BIT - 1, 0); return; } - STATIC VOID -MakeCrcTable () +MakeCrcTable ( + ) { - UINT32 i, j, r; + UINT32 i, j, r; for (i = 0; i <= UINT8_MAX; i++) { r = i; @@ -1121,6 +1174,7 @@ MakeCrcTable () r >>= 1; } } + mCrcTable[i] = (UINT16)r; } } @@ -1134,30 +1188,30 @@ MakeCrcTable () STATIC VOID PutBits ( - IN INT32 n, - IN UINT32 x + IN INT32 n, + IN UINT32 x ) { - UINT8 Temp; + UINT8 Temp; if (n < mBitCount) { mSubBitBuf |= x << (mBitCount -= n); } else { - Temp = (UINT8)(mSubBitBuf | (x >> (n -= mBitCount))); if (mDst < mDstUpperLimit) { *mDst++ = Temp; } + mCompSize++; if (n < UINT8_BIT) { mSubBitBuf = x << (mBitCount = UINT8_BIT - n); } else { - Temp = (UINT8)(x >> (n - UINT8_BIT)); if (mDst < mDstUpperLimit) { *mDst++ = Temp; } + mCompSize++; mSubBitBuf = x << (mBitCount = 2 * UINT8_BIT - n); @@ -1176,31 +1230,33 @@ PutBits ( STATIC INT32 FreadCrc ( - OUT UINT8 *p, - IN INT32 n + OUT UINT8 *p, + IN INT32 n ) { - INT32 i; + INT32 i; for (i = 0; mSrc < mSrcUpperLimit && i < n; i++) { *p++ = *mSrc++; } + n = i; - p -= n; + p -= n; mOrigSize += n; while (--i >= 0) { - UPDATE_CRC(*p++); + UPDATE_CRC (*p++); } + return n; } - STATIC VOID -InitPutBits () +InitPutBits ( + ) { - mBitCount = UINT8_BIT; + mBitCount = UINT8_BIT; mSubBitBuf = 0; } @@ -1212,17 +1268,17 @@ InitPutBits () STATIC VOID CountLen ( - IN INT32 i + IN INT32 i ) { - STATIC INT32 Depth = 0; + STATIC INT32 Depth = 0; if (i < mN) { mLenCnt[(Depth < 16) ? Depth : 16]++; } else { Depth++; - CountLen(mLeft [i]); - CountLen(mRight[i]); + CountLen (mLeft[i]); + CountLen (mRight[i]); Depth--; } } @@ -1235,16 +1291,17 @@ CountLen ( STATIC VOID MakeLen ( - IN INT32 Root + IN INT32 Root ) { - INT32 i, k; - UINT32 Cum; + INT32 i, k; + UINT32 Cum; for (i = 0; i <= 16; i++) { mLenCnt[i] = 0; } - CountLen(Root); + + CountLen (Root); // // Adjust the length count array so that @@ -1255,6 +1312,7 @@ MakeLen ( for (i = 16; i > 0; i--) { Cum += mLenCnt[i] << (16 - i); } + while (Cum != (1U << 16)) { mLenCnt[16]--; for (i = 15; i > 0; i--) { @@ -1264,8 +1322,10 @@ MakeLen ( break; } } + Cum--; } + for (i = 16; i > 0; i--) { k = mLenCnt[i]; while (--k >= 0) { @@ -1277,10 +1337,10 @@ MakeLen ( STATIC VOID DownHeap ( - IN INT32 i + IN INT32 i ) { - INT32 j, k; + INT32 j, k; // // priority queue: send i-th entry down heap @@ -1288,15 +1348,18 @@ DownHeap ( k = mHeap[i]; while ((j = 2 * i) <= mHeapSize) { - if (j < mHeapSize && mFreq[mHeap[j]] > mFreq[mHeap[j + 1]]) { + if ((j < mHeapSize) && (mFreq[mHeap[j]] > mFreq[mHeap[j + 1]])) { j++; } + if (mFreq[k] <= mFreq[mHeap[j]]) { break; } + mHeap[i] = mHeap[j]; - i = j; + i = j; } + mHeap[i] = (INT16)k; } @@ -1310,18 +1373,19 @@ DownHeap ( STATIC VOID MakeCode ( - IN INT32 n, - IN UINT8 Len[], - OUT UINT16 Code[] + IN INT32 n, + IN UINT8 Len[], + OUT UINT16 Code[] ) { - INT32 i; - UINT16 Start[18]; + INT32 i; + UINT16 Start[18]; Start[1] = 0; for (i = 1; i <= 16; i++) { Start[i + 1] = (UINT16)((Start[i] + mLenCnt[i]) << 1); } + for (i = 0; i < n; i++) { Code[i] = Start[Len[i]]++; } @@ -1346,62 +1410,65 @@ MakeTree ( OUT UINT16 CodeParm[] ) { - INT32 i, j, k, Avail; + INT32 i, j, k, Avail; // // make tree, calculate len[], return root // - mN = NParm; - mFreq = FreqParm; - mLen = LenParm; - Avail = mN; + mN = NParm; + mFreq = FreqParm; + mLen = LenParm; + Avail = mN; mHeapSize = 0; - mHeap[1] = 0; + mHeap[1] = 0; for (i = 0; i < mN; i++) { mLen[i] = 0; if (mFreq[i]) { mHeap[++mHeapSize] = (INT16)i; } } + if (mHeapSize < 2) { CodeParm[mHeap[1]] = 0; return mHeap[1]; } + for (i = mHeapSize / 2; i >= 1; i--) { - // // make priority queue // - DownHeap(i); + DownHeap (i); } + mSortPtr = CodeParm; do { i = mHeap[1]; if (i < mN) { *mSortPtr++ = (UINT16)i; } + mHeap[1] = mHeap[mHeapSize--]; - DownHeap(1); + DownHeap (1); j = mHeap[1]; if (j < mN) { *mSortPtr++ = (UINT16)j; } - k = Avail++; + + k = Avail++; mFreq[k] = (UINT16)(mFreq[i] + mFreq[j]); mHeap[1] = (INT16)k; - DownHeap(1); - mLeft[k] = (UINT16)i; + DownHeap (1); + mLeft[k] = (UINT16)i; mRight[k] = (UINT16)j; } while (mHeapSize > 1); mSortPtr = CodeParm; - MakeLen(k); - MakeCode(NParm, LenParm, CodeParm); + MakeLen (k); + MakeCode (NParm, LenParm, CodeParm); // // return root // return k; } - diff --git a/BaseTools/Source/C/Common/EfiUtilityMsgs.c b/BaseTools/Source/C/Common/EfiUtilityMsgs.c index 89524550884a..fa4c5ded0dce 100644 --- a/BaseTools/Source/C/Common/EfiUtilityMsgs.c +++ b/BaseTools/Source/C/Common/EfiUtilityMsgs.c @@ -18,17 +18,17 @@ SPDX-License-Identifier: BSD-2-Clause-Patent // Declare module globals for keeping track of the utility's // name and other settings. // -STATIC STATUS mStatus = STATUS_SUCCESS; -STATIC CHAR8 mUtilityName[50] = { 0 }; -STATIC UINT64 mPrintLogLevel = INFO_LOG_LEVEL; -STATIC CHAR8 *mSourceFileName = NULL; -STATIC UINT32 mSourceFileLineNum = 0; -STATIC UINT32 mErrorCount = 0; -STATIC UINT32 mWarningCount = 0; -STATIC UINT32 mMaxErrors = 0; -STATIC UINT32 mMaxWarnings = 0; -STATIC UINT32 mMaxWarningsPlusErrors = 0; -STATIC INT8 mPrintLimitsSet = 0; +STATIC STATUS mStatus = STATUS_SUCCESS; +STATIC CHAR8 mUtilityName[50] = { 0 }; +STATIC UINT64 mPrintLogLevel = INFO_LOG_LEVEL; +STATIC CHAR8 *mSourceFileName = NULL; +STATIC UINT32 mSourceFileLineNum = 0; +STATIC UINT32 mErrorCount = 0; +STATIC UINT32 mWarningCount = 0; +STATIC UINT32 mMaxErrors = 0; +STATIC UINT32 mMaxWarnings = 0; +STATIC UINT32 mMaxWarningsPlusErrors = 0; +STATIC INT8 mPrintLimitsSet = 0; STATIC VOID @@ -41,7 +41,7 @@ PrintLimitExceeded ( All arguments are optional, though the printed message may be useless if at least something valid is not specified. - + @note: We print the following (similar to the Warn() and Debug() W @@ -90,7 +90,8 @@ Error ( ... ) { - va_list List; + va_list List; + // // If limits have been set, then check that we have not exceeded them // @@ -101,16 +102,17 @@ Error ( if (mMaxWarningsPlusErrors != 0) { if (mErrorCount + mWarningCount > mMaxWarningsPlusErrors) { PrintLimitExceeded (); - return ; + return; } } + // // See if we've exceeded our error count // if (mMaxErrors != 0) { if (mErrorCount > mMaxErrors) { PrintLimitExceeded (); - return ; + return; } } } @@ -137,7 +139,8 @@ ParserError ( ... ) { - va_list List; + va_list List; + // // If limits have been set, then check them // @@ -148,16 +151,17 @@ ParserError ( if (mMaxWarningsPlusErrors != 0) { if (mErrorCount + mWarningCount > mMaxWarningsPlusErrors) { PrintLimitExceeded (); - return ; + return; } } + // // See if we've exceeded our error count // if (mMaxErrors != 0) { if (mErrorCount > mMaxErrors) { PrintLimitExceeded (); - return ; + return; } } } @@ -184,7 +188,8 @@ ParserWarning ( ... ) { - va_list List; + va_list List; + // // If limits have been set, then check them // @@ -195,16 +200,17 @@ ParserWarning ( if (mMaxWarningsPlusErrors != 0) { if (mErrorCount + mWarningCount > mMaxWarningsPlusErrors) { PrintLimitExceeded (); - return ; + return; } } + // // See if we've exceeded our warning count // if (mMaxWarnings != 0) { if (mWarningCount > mMaxWarnings) { PrintLimitExceeded (); - return ; + return; } } } @@ -244,7 +250,7 @@ Warning ( ... ) { - va_list List; + va_list List; // // Current Print Level not output warning information. @@ -252,6 +258,7 @@ Warning ( if (WARNING_LOG_LEVEL < mPrintLogLevel) { return; } + // // If limits have been set, then check them // @@ -262,16 +269,17 @@ Warning ( if (mMaxWarningsPlusErrors != 0) { if (mErrorCount + mWarningCount > mMaxWarningsPlusErrors) { PrintLimitExceeded (); - return ; + return; } } + // // See if we've exceeded our warning count // if (mMaxWarnings != 0) { if (mWarningCount > mMaxWarnings) { PrintLimitExceeded (); - return ; + return; } } } @@ -284,7 +292,7 @@ Warning ( /** Print a Debug message. - + @param FileName typically the name of the utility printing the debug message, but can be the name of a file being parsed. @param LineNumber the line number in FileName (parsers) @@ -304,12 +312,13 @@ DebugMsg ( ... ) { - va_list List; + va_list List; + // // If the debug level is less than current print level, then do nothing. // if (MsgLevel < mPrintLogLevel) { - return ; + return; } va_start (List, MsgFmt); @@ -321,7 +330,7 @@ DebugMsg ( Worker routine for all the utility printing services. Prints the message in a format that Visual Studio will find when scanning build outputs for errors or warnings. - + @note: If FileName == NULL then this utility will use the string passed into SetUtilityName(). @@ -355,25 +364,25 @@ DebugMsg ( **/ VOID PrintMessage ( - CHAR8 *Type, - CHAR8 *FileName, - UINT32 LineNumber, - UINT32 MessageCode, - CHAR8 *Text, - CHAR8 *MsgFmt, - va_list List + CHAR8 *Type, + CHAR8 *FileName, + UINT32 LineNumber, + UINT32 MessageCode, + CHAR8 *Text, + CHAR8 *MsgFmt, + va_list List ) { - CHAR8 Line[MAX_LINE_LEN]; - CHAR8 Line2[MAX_LINE_LEN]; - CHAR8 *Cptr; - struct tm *NewTime; - time_t CurrentTime; + CHAR8 Line[MAX_LINE_LEN]; + CHAR8 Line2[MAX_LINE_LEN]; + CHAR8 *Cptr; + struct tm *NewTime; + time_t CurrentTime; // // init local variable // - Line[0] = '\0'; + Line[0] = '\0'; Line2[0] = '\0'; // @@ -393,20 +402,23 @@ PrintMessage ( time (&CurrentTime); NewTime = localtime (&CurrentTime); if (NewTime != NULL) { - fprintf (stdout, "%04d-%02d-%02d %02d:%02d:%02d", - NewTime->tm_year + 1900, - NewTime->tm_mon + 1, - NewTime->tm_mday, - NewTime->tm_hour, - NewTime->tm_min, - NewTime->tm_sec - ); + fprintf ( + stdout, + "%04d-%02d-%02d %02d:%02d:%02d", + NewTime->tm_year + 1900, + NewTime->tm_mon + 1, + NewTime->tm_mday, + NewTime->tm_hour, + NewTime->tm_min, + NewTime->tm_sec + ); } + if (Cptr != NULL) { strcpy (Line, ": "); strncat (Line, Cptr, MAX_LINE_LEN - strlen (Line) - 1); if (LineNumber != 0) { - sprintf (Line2, "(%u)", (unsigned) LineNumber); + sprintf (Line2, "(%u)", (unsigned)LineNumber); strncat (Line, Line2, MAX_LINE_LEN - strlen (Line) - 1); } } @@ -418,10 +430,11 @@ PrintMessage ( if (mUtilityName[0] != '\0') { fprintf (stdout, "%s...\n", mUtilityName); } + strncpy (Line, Cptr, MAX_LINE_LEN - 1); Line[MAX_LINE_LEN - 1] = 0; if (LineNumber != 0) { - sprintf (Line2, "(%u)", (unsigned) LineNumber); + sprintf (Line2, "(%u)", (unsigned)LineNumber); strncat (Line, Line2, MAX_LINE_LEN - strlen (Line) - 1); } } else { @@ -448,9 +461,10 @@ PrintMessage ( strncat (Line, ": ", MAX_LINE_LEN - strlen (Line) - 1); strncat (Line, Type, MAX_LINE_LEN - strlen (Line) - 1); if (MessageCode != 0) { - sprintf (Line2, " %04u", (unsigned) MessageCode); + sprintf (Line2, " %04u", (unsigned)MessageCode); strncat (Line, Line2, MAX_LINE_LEN - strlen (Line) - 1); } + fprintf (stdout, "%s", Line); // // If offending text was provided, then print it @@ -458,6 +472,7 @@ PrintMessage ( if (Text != NULL) { fprintf (stdout, ": %s", Text); } + fprintf (stdout, "\n"); // @@ -467,7 +482,6 @@ PrintMessage ( vsprintf (Line2, MsgFmt, List); fprintf (stdout, " %s\n", Line2); } - } /** @@ -480,11 +494,12 @@ PrintMessage ( STATIC VOID PrintSimpleMessage ( - CHAR8 *MsgFmt, - va_list List + CHAR8 *MsgFmt, + va_list List ) { - CHAR8 Line[MAX_LINE_LEN]; + CHAR8 Line[MAX_LINE_LEN]; + // // Print formatted message if provided // @@ -507,8 +522,8 @@ ParserSetPosition ( UINT32 LineNum ) { - mSourceFileName = SourceFileName; - mSourceFileLineNum = LineNum; + mSourceFileName = SourceFileName; + mSourceFileLineNum = LineNum; } /** @@ -523,7 +538,7 @@ ParserSetPosition ( **/ VOID SetUtilityName ( - CHAR8 *UtilityName + CHAR8 *UtilityName ) { // @@ -534,6 +549,7 @@ SetUtilityName ( if (strlen (UtilityName) >= sizeof (mUtilityName)) { Error (UtilityName, 0, 0, "application error", "utility name length exceeds internal buffer size"); } + strncpy (mUtilityName, UtilityName, sizeof (mUtilityName) - 1); mUtilityName[sizeof (mUtilityName) - 1] = 0; } else { @@ -580,16 +596,17 @@ SetPrintLevel ( **/ VOID VerboseMsg ( - CHAR8 *MsgFmt, + CHAR8 *MsgFmt, ... ) { - va_list List; + va_list List; + // // If the debug level is less than current print level, then do nothing. // if (VERBOSE_LOG_LEVEL < mPrintLogLevel) { - return ; + return; } va_start (List, MsgFmt); @@ -606,16 +623,17 @@ VerboseMsg ( **/ VOID NormalMsg ( - CHAR8 *MsgFmt, + CHAR8 *MsgFmt, ... ) { - va_list List; + va_list List; + // // If the debug level is less than current print level, then do nothing. // if (INFO_LOG_LEVEL < mPrintLogLevel) { - return ; + return; } va_start (List, MsgFmt); @@ -632,16 +650,17 @@ NormalMsg ( **/ VOID KeyMsg ( - CHAR8 *MsgFmt, + CHAR8 *MsgFmt, ... ) { - va_list List; + va_list List; + // // If the debug level is less than current print level, then do nothing. // if (KEY_LOG_LEVEL < mPrintLogLevel) { - return ; + return; } va_start (List, MsgFmt); @@ -665,10 +684,10 @@ SetPrintLimits ( UINT32 MaxWarningsPlusErrors ) { - mMaxErrors = MaxErrors; - mMaxWarnings = MaxWarnings; - mMaxWarningsPlusErrors = MaxWarningsPlusErrors; - mPrintLimitsSet = 1; + mMaxErrors = MaxErrors; + mMaxWarnings = MaxWarnings; + mMaxWarningsPlusErrors = MaxWarningsPlusErrors; + mPrintLimitsSet = 1; } STATIC @@ -677,7 +696,8 @@ PrintLimitExceeded ( VOID ) { - STATIC INT8 mPrintLimitExceeded = 0; + STATIC INT8 mPrintLimitExceeded = 0; + // // If we've already printed the message, do nothing. Otherwise // temporarily increase our print limits so we can pass one @@ -701,10 +721,10 @@ TestUtilityMessages ( VOID ) { - CHAR8 *ArgStr = "ArgString"; - int ArgInt; + CHAR8 *ArgStr = "ArgString"; + int ArgInt; - ArgInt = 0x12345678; + ArgInt = 0x12345678; // // Test without setting utility name // @@ -785,4 +805,5 @@ TestUtilityMessages ( ParserSetPosition (__FILE__, __LINE__ + 1); ParserWarning (4321, "Text1", "Text2 %s 0x%X", ArgStr, ArgInt); } + #endif diff --git a/BaseTools/Source/C/Common/FirmwareVolumeBuffer.c b/BaseTools/Source/C/Common/FirmwareVolumeBuffer.c index 3fae6f901da0..9a94461e4e57 100644 --- a/BaseTools/Source/C/Common/FirmwareVolumeBuffer.c +++ b/BaseTools/Source/C/Common/FirmwareVolumeBuffer.c @@ -19,40 +19,44 @@ SPDX-License-Identifier: BSD-2-Clause-Patent ) \ ) - // // Local prototypes // STATIC UINT32 -FvBufGetSecHdrLen( - IN EFI_COMMON_SECTION_HEADER *SectionHeader - ) +FvBufGetSecHdrLen ( + IN EFI_COMMON_SECTION_HEADER *SectionHeader + ) { if (SectionHeader == NULL) { return 0; } - if (FvBufExpand3ByteSize(SectionHeader->Size) == 0xffffff) { - return sizeof(EFI_COMMON_SECTION_HEADER2); + + if (FvBufExpand3ByteSize (SectionHeader->Size) == 0xffffff) { + return sizeof (EFI_COMMON_SECTION_HEADER2); } - return sizeof(EFI_COMMON_SECTION_HEADER); + + return sizeof (EFI_COMMON_SECTION_HEADER); } STATIC UINT32 FvBufGetSecFileLen ( - IN EFI_COMMON_SECTION_HEADER *SectionHeader + IN EFI_COMMON_SECTION_HEADER *SectionHeader ) { - UINT32 Length; + UINT32 Length; + if (SectionHeader == NULL) { return 0; } - Length = FvBufExpand3ByteSize(SectionHeader->Size); + + Length = FvBufExpand3ByteSize (SectionHeader->Size); if (Length == 0xffffff) { Length = ((EFI_COMMON_SECTION_HEADER2 *)SectionHeader)->ExtendedSize; } + return Length; } @@ -63,15 +67,15 @@ FvBufGetSecFileLen ( STATIC UINT16 FvBufCalculateChecksum16 ( - IN UINT16 *Buffer, - IN UINTN Size + IN UINT16 *Buffer, + IN UINTN Size ); STATIC UINT8 FvBufCalculateChecksum8 ( - IN UINT8 *Buffer, - IN UINTN Size + IN UINT8 *Buffer, + IN UINTN Size ); // @@ -90,19 +94,19 @@ FvBufCalculateChecksum8 ( **/ EFI_STATUS FvBufRemoveFileNew ( - IN OUT VOID *Fv, - IN EFI_GUID *Name + IN OUT VOID *Fv, + IN EFI_GUID *Name ) { - EFI_STATUS Status; - EFI_FFS_FILE_HEADER* FileToRm; - UINTN FileToRmLength; + EFI_STATUS Status; + EFI_FFS_FILE_HEADER *FileToRm; + UINTN FileToRmLength; - Status = FvBufFindFileByName( - Fv, - Name, - (VOID **)&FileToRm - ); + Status = FvBufFindFileByName ( + Fv, + Name, + (VOID **)&FileToRm + ); if (EFI_ERROR (Status)) { return Status; } @@ -112,7 +116,7 @@ FvBufRemoveFileNew ( CommonLibBinderSetMem ( FileToRm, FileToRmLength, - (((EFI_FIRMWARE_VOLUME_HEADER*)Fv)->Attributes & EFI_FVB2_ERASE_POLARITY) + (((EFI_FIRMWARE_VOLUME_HEADER *)Fv)->Attributes & EFI_FVB2_ERASE_POLARITY) ? 0xFF : 0 ); @@ -131,21 +135,21 @@ FvBufRemoveFileNew ( **/ EFI_STATUS FvBufRemoveFile ( - IN OUT VOID *Fv, - IN EFI_GUID *Name + IN OUT VOID *Fv, + IN EFI_GUID *Name ) { EFI_STATUS Status; - EFI_FFS_FILE_HEADER *NextFile; - EFI_FIRMWARE_VOLUME_HEADER *TempFv; + EFI_FFS_FILE_HEADER *NextFile; + EFI_FIRMWARE_VOLUME_HEADER *TempFv; UINTN FileKey; UINTN FvLength; - Status = FvBufFindFileByName( - Fv, - Name, - NULL - ); + Status = FvBufFindFileByName ( + Fv, + Name, + NULL + ); if (EFI_ERROR (Status)) { return Status; } @@ -172,7 +176,6 @@ FvBufRemoveFile ( FileKey = 0; while (TRUE) { - Status = FvBufFindNextFile (Fv, &FileKey, (VOID **)&NextFile); if (Status == EFI_NOT_FOUND) { break; @@ -183,8 +186,7 @@ FvBufRemoveFile ( if (CommonLibBinderCompareGuid (Name, &NextFile->Name)) { continue; - } - else { + } else { Status = FvBufAddFile (TempFv, NextFile); if (EFI_ERROR (Status)) { CommonLibBinderFree (TempFv); @@ -209,12 +211,12 @@ FvBufRemoveFile ( **/ EFI_STATUS FvBufChecksumFile ( - IN OUT VOID *FfsFile + IN OUT VOID *FfsFile ) { - EFI_FFS_FILE_HEADER* File = (EFI_FFS_FILE_HEADER*)FfsFile; - EFI_FFS_FILE_STATE StateBackup; - UINT32 FileSize; + EFI_FFS_FILE_HEADER *File = (EFI_FFS_FILE_HEADER *)FfsFile; + EFI_FFS_FILE_STATE StateBackup; + UINT32 FileSize; FileSize = FvBufGetFfsFileSize (File); @@ -222,21 +224,21 @@ FvBufChecksumFile ( // Fill in checksums and state, they must be 0 for checksumming. // File->IntegrityCheck.Checksum.Header = 0; - File->IntegrityCheck.Checksum.File = 0; - StateBackup = File->State; - File->State = 0; + File->IntegrityCheck.Checksum.File = 0; + StateBackup = File->State; + File->State = 0; File->IntegrityCheck.Checksum.Header = FvBufCalculateChecksum8 ( - (UINT8 *) File, + (UINT8 *)File, FvBufGetFfsHeaderSize (File) ); if (File->Attributes & FFS_ATTRIB_CHECKSUM) { File->IntegrityCheck.Checksum.File = FvBufCalculateChecksum8 ( - (VOID*)((UINT8 *)File + FvBufGetFfsHeaderSize (File)), - FileSize - FvBufGetFfsHeaderSize (File) - ); + (VOID *)((UINT8 *)File + FvBufGetFfsHeaderSize (File)), + FileSize - FvBufGetFfsHeaderSize (File) + ); } else { File->IntegrityCheck.Checksum.File = FFS_FIXED_CHECKSUM; } @@ -258,15 +260,15 @@ FvBufChecksumFile ( **/ EFI_STATUS FvBufChecksumHeader ( - IN OUT VOID *Fv + IN OUT VOID *Fv ) { - EFI_FIRMWARE_VOLUME_HEADER* FvHeader = (EFI_FIRMWARE_VOLUME_HEADER*)Fv; + EFI_FIRMWARE_VOLUME_HEADER *FvHeader = (EFI_FIRMWARE_VOLUME_HEADER *)Fv; FvHeader->Checksum = 0; FvHeader->Checksum = FvBufCalculateChecksum16 ( - (UINT16*) FvHeader, + (UINT16 *)FvHeader, FvHeader->HeaderLength / sizeof (UINT16) ); @@ -286,12 +288,12 @@ FvBufChecksumHeader ( **/ EFI_STATUS FvBufDuplicate ( - IN VOID *SourceFv, - IN OUT VOID **DestinationFv + IN VOID *SourceFv, + IN OUT VOID **DestinationFv ) { - EFI_STATUS Status; - UINTN size; + EFI_STATUS Status; + UINTN size; if (DestinationFv == NULL) { return EFI_INVALID_PARAMETER; @@ -331,18 +333,18 @@ FvBufDuplicate ( **/ EFI_STATUS FvBufExtend ( - IN VOID **Fv, - IN UINTN Size + IN VOID **Fv, + IN UINTN Size ) { - EFI_STATUS Status; - UINTN OldSize; - UINTN NewSize; - UINTN BlockCount; - VOID* NewFv; + EFI_STATUS Status; + UINTN OldSize; + UINTN NewSize; + UINTN BlockCount; + VOID *NewFv; - EFI_FIRMWARE_VOLUME_HEADER* hdr; - EFI_FV_BLOCK_MAP_ENTRY* blk; + EFI_FIRMWARE_VOLUME_HEADER *hdr; + EFI_FV_BLOCK_MAP_ENTRY *blk; Status = FvBufGetSize (*Fv, &OldSize); if (EFI_ERROR (Status)) { @@ -352,7 +354,7 @@ FvBufExtend ( // // Locate the block map in the fv header // - hdr = (EFI_FIRMWARE_VOLUME_HEADER*)*Fv; + hdr = (EFI_FIRMWARE_VOLUME_HEADER *)*Fv; blk = hdr->BlockMap; // @@ -384,9 +386,9 @@ FvBufExtend ( // // Locate the block map in the new fv header // - hdr = (EFI_FIRMWARE_VOLUME_HEADER*)NewFv; + hdr = (EFI_FIRMWARE_VOLUME_HEADER *)NewFv; hdr->FvLength = NewSize; - blk = hdr->BlockMap; + blk = hdr->BlockMap; // // Update the block map for the new fv @@ -402,7 +404,7 @@ FvBufExtend ( // Clear out the new area of the FV // CommonLibBinderSetMem ( - (UINT8*)NewFv + OldSize, + (UINT8 *)NewFv + OldSize, (NewSize - OldSize), (hdr->Attributes & EFI_FVB2_ERASE_POLARITY) ? 0xFF : 0 ); @@ -413,7 +415,6 @@ FvBufExtend ( *Fv = NewFv; return EFI_SUCCESS; - } /** @@ -425,20 +426,20 @@ FvBufExtend ( **/ EFI_STATUS FvBufClearAllFiles ( - IN OUT VOID *Fv + IN OUT VOID *Fv ) { - EFI_FIRMWARE_VOLUME_HEADER *hdr = (EFI_FIRMWARE_VOLUME_HEADER*)Fv; - EFI_STATUS Status; - UINTN size = 0; + EFI_FIRMWARE_VOLUME_HEADER *hdr = (EFI_FIRMWARE_VOLUME_HEADER *)Fv; + EFI_STATUS Status; + UINTN size = 0; Status = FvBufGetSize (Fv, &size); if (EFI_ERROR (Status)) { return Status; } - CommonLibBinderSetMem( - (UINT8*)hdr + hdr->HeaderLength, + CommonLibBinderSetMem ( + (UINT8 *)hdr + hdr->HeaderLength, size - hdr->HeaderLength, (hdr->Attributes & EFI_FVB2_ERASE_POLARITY) ? 0xFF : 0 ); @@ -455,12 +456,12 @@ FvBufClearAllFiles ( **/ EFI_STATUS FvBufGetSize ( - IN VOID *Fv, - OUT UINTN *Size + IN VOID *Fv, + OUT UINTN *Size ) { - EFI_FIRMWARE_VOLUME_HEADER *hdr = (EFI_FIRMWARE_VOLUME_HEADER*)Fv; - EFI_FV_BLOCK_MAP_ENTRY *blk = hdr->BlockMap; + EFI_FIRMWARE_VOLUME_HEADER *hdr = (EFI_FIRMWARE_VOLUME_HEADER *)Fv; + EFI_FV_BLOCK_MAP_ENTRY *blk = hdr->BlockMap; *Size = 0; @@ -470,6 +471,7 @@ FvBufGetSize ( // If size is greater than 1GB, then assume it is corrupted return EFI_VOLUME_CORRUPTED; } + blk++; } @@ -491,21 +493,21 @@ FvBufGetSize ( **/ EFI_STATUS FvBufAddFile ( - IN OUT VOID *Fv, - IN VOID *File + IN OUT VOID *Fv, + IN VOID *File ) { - EFI_FIRMWARE_VOLUME_HEADER *hdr = (EFI_FIRMWARE_VOLUME_HEADER*)Fv; + EFI_FIRMWARE_VOLUME_HEADER *hdr = (EFI_FIRMWARE_VOLUME_HEADER *)Fv; - EFI_FFS_FILE_HEADER *fhdr = NULL; - EFI_FVB_ATTRIBUTES_2 FvbAttributes; - UINTN offset; - UINTN fsize; - UINTN newSize; - UINTN clearLoop; + EFI_FFS_FILE_HEADER *fhdr = NULL; + EFI_FVB_ATTRIBUTES_2 FvbAttributes; + UINTN offset; + UINTN fsize; + UINTN newSize; + UINTN clearLoop; - EFI_STATUS Status; - UINTN fvSize; + EFI_STATUS Status; + UINTN fvSize; Status = FvBufGetSize (Fv, &fvSize); if (EFI_ERROR (Status)) { @@ -513,27 +515,28 @@ FvBufAddFile ( } FvbAttributes = hdr->Attributes; - newSize = FvBufGetFfsFileSize ((EFI_FFS_FILE_HEADER*)File); + newSize = FvBufGetFfsFileSize ((EFI_FFS_FILE_HEADER *)File); - for( - offset = (UINTN)ALIGN_POINTER (hdr->HeaderLength, 8); - offset + newSize <= fvSize; - offset = (UINTN)ALIGN_POINTER (offset, 8) - ) { + for ( + offset = (UINTN)ALIGN_POINTER (hdr->HeaderLength, 8); + offset + newSize <= fvSize; + offset = (UINTN)ALIGN_POINTER (offset, 8) + ) + { + fhdr = (EFI_FFS_FILE_HEADER *)((UINT8 *)hdr + offset); - fhdr = (EFI_FFS_FILE_HEADER*) ((UINT8*)hdr + offset); - - if (EFI_TEST_FFS_ATTRIBUTES_BIT( + if (EFI_TEST_FFS_ATTRIBUTES_BIT ( FvbAttributes, fhdr->State, EFI_FILE_HEADER_VALID + ) ) - ) { + { // BUGBUG: Need to make sure that the new file does not already // exist. fsize = FvBufGetFfsFileSize (fhdr); - if (fsize == 0 || (offset + fsize > fvSize)) { + if ((fsize == 0) || (offset + fsize > fvSize)) { return EFI_VOLUME_CORRUPTED; } @@ -543,10 +546,11 @@ FvBufAddFile ( clearLoop = 0; while ((clearLoop < newSize) && - (((UINT8*)fhdr)[clearLoop] == - (UINT8)((hdr->Attributes & EFI_FVB2_ERASE_POLARITY) ? 0xFF : 0) + (((UINT8 *)fhdr)[clearLoop] == + (UINT8)((hdr->Attributes & EFI_FVB2_ERASE_POLARITY) ? 0xFF : 0) ) - ) { + ) + { clearLoop++; } @@ -584,14 +588,14 @@ FvBufAddFile ( **/ EFI_STATUS FvBufAddFileWithExtend ( - IN OUT VOID **Fv, - IN VOID *File + IN OUT VOID **Fv, + IN VOID *File ) { - EFI_STATUS Status; - EFI_FFS_FILE_HEADER* NewFile; + EFI_STATUS Status; + EFI_FFS_FILE_HEADER *NewFile; - NewFile = (EFI_FFS_FILE_HEADER*)File; + NewFile = (EFI_FFS_FILE_HEADER *)File; // // Try to add to the capsule volume @@ -626,25 +630,25 @@ FvBufAddFileWithExtend ( **/ EFI_STATUS FvBufAddVtfFile ( - IN OUT VOID *Fv, - IN VOID *File + IN OUT VOID *Fv, + IN VOID *File ) { - EFI_STATUS Status; + EFI_STATUS Status; - EFI_FIRMWARE_VOLUME_HEADER *hdr = (EFI_FIRMWARE_VOLUME_HEADER*)Fv; + EFI_FIRMWARE_VOLUME_HEADER *hdr = (EFI_FIRMWARE_VOLUME_HEADER *)Fv; - EFI_FFS_FILE_HEADER* NewFile; + EFI_FFS_FILE_HEADER *NewFile; UINTN NewFileSize; - UINT8 erasedUint8; - UINTN clearLoop; + UINT8 erasedUint8; + UINTN clearLoop; - EFI_FFS_FILE_HEADER *LastFile; - UINTN LastFileSize; + EFI_FFS_FILE_HEADER *LastFile; + UINTN LastFileSize; - UINTN fvSize; - UINTN Key; + UINTN fvSize; + UINTN Key; Status = FvBufGetSize (Fv, &fvSize); if (EFI_ERROR (Status)) { @@ -652,7 +656,7 @@ FvBufAddVtfFile ( } erasedUint8 = (UINT8)((hdr->Attributes & EFI_FVB2_ERASE_POLARITY) ? 0xFF : 0); - NewFileSize = FvBufGetFfsFileSize ((EFI_FFS_FILE_HEADER*)File); + NewFileSize = FvBufGetFfsFileSize ((EFI_FFS_FILE_HEADER *)File); if (NewFileSize != (UINTN)ALIGN_POINTER (NewFileSize, 8)) { return EFI_INVALID_PARAMETER; @@ -661,31 +665,31 @@ FvBufAddVtfFile ( // // Find the last file in the FV // - Key = 0; - LastFile = NULL; + Key = 0; + LastFile = NULL; LastFileSize = 0; do { - Status = FvBufFindNextFile (Fv, &Key, (VOID **)&LastFile); - LastFileSize = FvBufGetFfsFileSize ((EFI_FFS_FILE_HEADER*)File); + Status = FvBufFindNextFile (Fv, &Key, (VOID **)&LastFile); + LastFileSize = FvBufGetFfsFileSize ((EFI_FFS_FILE_HEADER *)File); } while (!EFI_ERROR (Status)); // // If no files were found, then we start at the beginning of the FV // if (LastFile == NULL) { - LastFile = (EFI_FFS_FILE_HEADER*)((UINT8*)hdr + hdr->HeaderLength); + LastFile = (EFI_FFS_FILE_HEADER *)((UINT8 *)hdr + hdr->HeaderLength); } // // We want to put the new file (VTF) at the end of the FV // - NewFile = (EFI_FFS_FILE_HEADER*)((UINT8*)hdr + (fvSize - NewFileSize)); + NewFile = (EFI_FFS_FILE_HEADER *)((UINT8 *)hdr + (fvSize - NewFileSize)); // // Check to see if there is enough room for the VTF after the last file // found in the FV // - if ((UINT8*)NewFile < ((UINT8*)LastFile + LastFileSize)) { + if ((UINT8 *)NewFile < ((UINT8 *)LastFile + LastFileSize)) { return EFI_OUT_OF_RESOURCES; } @@ -694,8 +698,9 @@ FvBufAddVtfFile ( // clearLoop = 0; while ((clearLoop < NewFileSize) && - (((UINT8*)NewFile)[clearLoop] == erasedUint8) - ) { + (((UINT8 *)NewFile)[clearLoop] == erasedUint8) + ) + { clearLoop++; } @@ -720,13 +725,13 @@ FvBufAddVtfFile ( **/ VOID FvBufCompact3ByteSize ( - OUT VOID* SizeDest, - IN UINT32 Size + OUT VOID *SizeDest, + IN UINT32 Size ) { - ((UINT8*)SizeDest)[0] = (UINT8)Size; - ((UINT8*)SizeDest)[1] = (UINT8)(Size >> 8); - ((UINT8*)SizeDest)[2] = (UINT8)(Size >> 16); + ((UINT8 *)SizeDest)[0] = (UINT8)Size; + ((UINT8 *)SizeDest)[1] = (UINT8)(Size >> 8); + ((UINT8 *)SizeDest)[2] = (UINT8)(Size >> 16); } /** @@ -738,16 +743,18 @@ FvBufCompact3ByteSize ( **/ UINT32 FvBufGetFfsFileSize ( - IN EFI_FFS_FILE_HEADER *Ffs + IN EFI_FFS_FILE_HEADER *Ffs ) { if (Ffs == NULL) { return 0; } + if (Ffs->Attributes & FFS_ATTRIB_LARGE_FILE) { - return (UINT32) ((EFI_FFS_FILE_HEADER2 *)Ffs)->ExtendedSize; + return (UINT32)((EFI_FFS_FILE_HEADER2 *)Ffs)->ExtendedSize; } - return FvBufExpand3ByteSize(Ffs->Size); + + return FvBufExpand3ByteSize (Ffs->Size); } /** @@ -759,16 +766,18 @@ FvBufGetFfsFileSize ( **/ UINT32 FvBufGetFfsHeaderSize ( - IN EFI_FFS_FILE_HEADER *Ffs + IN EFI_FFS_FILE_HEADER *Ffs ) { if (Ffs == NULL) { return 0; } + if (Ffs->Attributes & FFS_ATTRIB_LARGE_FILE) { - return sizeof(EFI_FFS_FILE_HEADER2); + return sizeof (EFI_FFS_FILE_HEADER2); } - return sizeof(EFI_FFS_FILE_HEADER); + + return sizeof (EFI_FFS_FILE_HEADER); } /** @@ -780,12 +789,12 @@ FvBufGetFfsHeaderSize ( **/ UINT32 FvBufExpand3ByteSize ( - IN VOID* Size + IN VOID *Size ) { - return (((UINT8*)Size)[2] << 16) + - (((UINT8*)Size)[1] << 8) + - ((UINT8*)Size)[0]; + return (((UINT8 *)Size)[2] << 16) + + (((UINT8 *)Size)[1] << 8) + + ((UINT8 *)Size)[0]; } /** @@ -805,19 +814,19 @@ FvBufExpand3ByteSize ( **/ EFI_STATUS FvBufFindNextFile ( - IN VOID *Fv, - IN OUT UINTN *Key, - OUT VOID **File + IN VOID *Fv, + IN OUT UINTN *Key, + OUT VOID **File ) { - EFI_FIRMWARE_VOLUME_HEADER *hdr = (EFI_FIRMWARE_VOLUME_HEADER*)Fv; + EFI_FIRMWARE_VOLUME_HEADER *hdr = (EFI_FIRMWARE_VOLUME_HEADER *)Fv; - EFI_FFS_FILE_HEADER *fhdr = NULL; - EFI_FVB_ATTRIBUTES_2 FvbAttributes; - UINTN fsize; + EFI_FFS_FILE_HEADER *fhdr = NULL; + EFI_FVB_ATTRIBUTES_2 FvbAttributes; + UINTN fsize; - EFI_STATUS Status; - UINTN fvSize; + EFI_STATUS Status; + UINTN fvSize; if (Fv == NULL) { return EFI_INVALID_PARAMETER; @@ -834,50 +843,53 @@ FvBufFindNextFile ( FvbAttributes = hdr->Attributes; - for( - *Key = (UINTN)ALIGN_POINTER (*Key, 8); - (*Key + sizeof (*fhdr)) < fvSize; - *Key = (UINTN)ALIGN_POINTER (*Key, 8) - ) { - - fhdr = (EFI_FFS_FILE_HEADER*) ((UINT8*)hdr + *Key); + for ( + *Key = (UINTN)ALIGN_POINTER (*Key, 8); + (*Key + sizeof (*fhdr)) < fvSize; + *Key = (UINTN)ALIGN_POINTER (*Key, 8) + ) + { + fhdr = (EFI_FFS_FILE_HEADER *)((UINT8 *)hdr + *Key); fsize = FvBufGetFfsFileSize (fhdr); - if (!EFI_TEST_FFS_ATTRIBUTES_BIT( - FvbAttributes, - fhdr->State, - EFI_FILE_HEADER_VALID - ) || - EFI_TEST_FFS_ATTRIBUTES_BIT( + if (!EFI_TEST_FFS_ATTRIBUTES_BIT ( + FvbAttributes, + fhdr->State, + EFI_FILE_HEADER_VALID + ) || + EFI_TEST_FFS_ATTRIBUTES_BIT ( FvbAttributes, fhdr->State, EFI_FILE_HEADER_INVALID + ) ) - ) { + { *Key = *Key + 1; // Make some forward progress continue; - } else if( - EFI_TEST_FFS_ATTRIBUTES_BIT( - FvbAttributes, - fhdr->State, - EFI_FILE_MARKED_FOR_UPDATE - ) || - EFI_TEST_FFS_ATTRIBUTES_BIT( - FvbAttributes, - fhdr->State, - EFI_FILE_DELETED - ) - ) { + } else if ( + EFI_TEST_FFS_ATTRIBUTES_BIT ( + FvbAttributes, + fhdr->State, + EFI_FILE_MARKED_FOR_UPDATE + ) || + EFI_TEST_FFS_ATTRIBUTES_BIT ( + FvbAttributes, + fhdr->State, + EFI_FILE_DELETED + ) + ) + { *Key = *Key + fsize; continue; - } else if (EFI_TEST_FFS_ATTRIBUTES_BIT( - FvbAttributes, - fhdr->State, - EFI_FILE_DATA_VALID - ) - ) { - *File = (UINT8*)hdr + *Key; - *Key = *Key + fsize; + } else if (EFI_TEST_FFS_ATTRIBUTES_BIT ( + FvbAttributes, + fhdr->State, + EFI_FILE_DATA_VALID + ) + ) + { + *File = (UINT8 *)hdr + *Key; + *Key = *Key + fsize; return EFI_SUCCESS; } @@ -903,14 +915,14 @@ FvBufFindNextFile ( **/ EFI_STATUS FvBufFindFileByName ( - IN VOID *Fv, - IN EFI_GUID *Name, - OUT VOID **File + IN VOID *Fv, + IN EFI_GUID *Name, + OUT VOID **File ) { - EFI_STATUS Status; - UINTN Key; - EFI_FFS_FILE_HEADER *NextFile; + EFI_STATUS Status; + UINTN Key; + EFI_FFS_FILE_HEADER *NextFile; Key = 0; while (TRUE) { @@ -923,6 +935,7 @@ FvBufFindFileByName ( if (File != NULL) { *File = NextFile; } + return EFI_SUCCESS; } } @@ -946,14 +959,14 @@ FvBufFindFileByName ( **/ EFI_STATUS FvBufFindFileByType ( - IN VOID *Fv, - IN EFI_FV_FILETYPE Type, - OUT VOID **File + IN VOID *Fv, + IN EFI_FV_FILETYPE Type, + OUT VOID **File ) { - EFI_STATUS Status; - UINTN Key; - EFI_FFS_FILE_HEADER *NextFile; + EFI_STATUS Status; + UINTN Key; + EFI_FFS_FILE_HEADER *NextFile; Key = 0; while (TRUE) { @@ -966,6 +979,7 @@ FvBufFindFileByType ( if (File != NULL) { *File = NextFile; } + return EFI_SUCCESS; } } @@ -988,16 +1002,16 @@ FvBufFindFileByType ( **/ EFI_STATUS FvBufGetFileRawData ( - IN VOID* FfsFile, - OUT VOID** RawData, - OUT UINTN* RawDataSize + IN VOID *FfsFile, + OUT VOID **RawData, + OUT UINTN *RawDataSize ) { - EFI_STATUS Status; - EFI_FFS_FILE_HEADER* File; - EFI_RAW_SECTION* Section; + EFI_STATUS Status; + EFI_FFS_FILE_HEADER *File; + EFI_RAW_SECTION *Section; - File = (EFI_FFS_FILE_HEADER*)FfsFile; + File = (EFI_FFS_FILE_HEADER *)FfsFile; // // Is the file type == EFI_FV_FILETYPE_RAW? @@ -1006,7 +1020,7 @@ FvBufGetFileRawData ( // // Raw filetypes don't have sections, so we just return the raw data // - *RawData = (VOID*)((UINT8 *)File + FvBufGetFfsHeaderSize (File)); + *RawData = (VOID *)((UINT8 *)File + FvBufGetFfsHeaderSize (File)); *RawDataSize = FvBufGetFfsFileSize (File) - FvBufGetFfsHeaderSize (File); return EFI_SUCCESS; } @@ -1019,12 +1033,11 @@ FvBufGetFileRawData ( return Status; } - *RawData = (VOID*)((UINT8 *)Section + FvBufGetSecHdrLen(Section)); + *RawData = (VOID *)((UINT8 *)Section + FvBufGetSecHdrLen (Section)); *RawDataSize = - FvBufGetSecFileLen (Section) - FvBufGetSecHdrLen(Section); + FvBufGetSecFileLen (Section) - FvBufGetSecHdrLen (Section); return EFI_SUCCESS; - } /** @@ -1042,37 +1055,37 @@ FvBufGetFileRawData ( **/ EFI_STATUS FvBufPackageFreeformRawFile ( - IN EFI_GUID* Filename, - IN VOID* RawData, - IN UINTN RawDataSize, - OUT VOID** FfsFile + IN EFI_GUID *Filename, + IN VOID *RawData, + IN UINTN RawDataSize, + OUT VOID **FfsFile ) { - EFI_FFS_FILE_HEADER* NewFile; - UINT32 NewFileSize; - EFI_RAW_SECTION* NewSection; - UINT32 NewSectionSize; - UINT32 FfsHdrLen; - UINT32 SecHdrLen; + EFI_FFS_FILE_HEADER *NewFile; + UINT32 NewFileSize; + EFI_RAW_SECTION *NewSection; + UINT32 NewSectionSize; + UINT32 FfsHdrLen; + UINT32 SecHdrLen; // // The section size is the DataSize + the size of the section header // NewSectionSize = (UINT32)sizeof (EFI_RAW_SECTION) + (UINT32)RawDataSize; - SecHdrLen = sizeof (EFI_RAW_SECTION); + SecHdrLen = sizeof (EFI_RAW_SECTION); if (NewSectionSize >= MAX_SECTION_SIZE) { NewSectionSize = (UINT32)sizeof (EFI_RAW_SECTION2) + (UINT32)RawDataSize; - SecHdrLen = sizeof (EFI_RAW_SECTION2); + SecHdrLen = sizeof (EFI_RAW_SECTION2); } // // The file size is the size of the file header + the section size // NewFileSize = sizeof (EFI_FFS_FILE_HEADER) + NewSectionSize; - FfsHdrLen = sizeof (EFI_FFS_FILE_HEADER); + FfsHdrLen = sizeof (EFI_FFS_FILE_HEADER); if (NewFileSize >= MAX_FFS_SIZE) { NewFileSize = sizeof (EFI_FFS_FILE_HEADER2) + NewSectionSize; - FfsHdrLen = sizeof (EFI_FFS_FILE_HEADER2); + FfsHdrLen = sizeof (EFI_FFS_FILE_HEADER2); } // @@ -1082,18 +1095,20 @@ FvBufPackageFreeformRawFile ( if (NewFile == NULL) { return EFI_OUT_OF_RESOURCES; } + CommonLibBinderSetMem (NewFile, NewFileSize, 0); // // The NewSection follow right after the FFS file header // - NewSection = (EFI_RAW_SECTION*)((UINT8*)NewFile + FfsHdrLen); + NewSection = (EFI_RAW_SECTION *)((UINT8 *)NewFile + FfsHdrLen); if (NewSectionSize >= MAX_SECTION_SIZE) { FvBufCompact3ByteSize (NewSection->Size, 0xffffff); ((EFI_RAW_SECTION2 *)NewSection)->ExtendedSize = NewSectionSize; } else { FvBufCompact3ByteSize (NewSection->Size, NewSectionSize); } + NewSection->Type = EFI_SECTION_RAW; // @@ -1109,18 +1124,19 @@ FvBufPackageFreeformRawFile ( if (NewFileSize >= MAX_FFS_SIZE) { FvBufCompact3ByteSize (NewFile->Size, 0x0); ((EFI_FFS_FILE_HEADER2 *)NewFile)->ExtendedSize = NewFileSize; - NewFile->Attributes |= FFS_ATTRIB_LARGE_FILE; + NewFile->Attributes |= FFS_ATTRIB_LARGE_FILE; } else { FvBufCompact3ByteSize (NewFile->Size, NewFileSize); } - NewFile->Type = EFI_FV_FILETYPE_FREEFORM; + + NewFile->Type = EFI_FV_FILETYPE_FREEFORM; NewFile->IntegrityCheck.Checksum.Header = - FvBufCalculateChecksum8 ((UINT8*)NewFile, FfsHdrLen); + FvBufCalculateChecksum8 ((UINT8 *)NewFile, FfsHdrLen); NewFile->IntegrityCheck.Checksum.File = FFS_FIXED_CHECKSUM; - NewFile->State = (UINT8)~( EFI_FILE_HEADER_CONSTRUCTION | - EFI_FILE_HEADER_VALID | - EFI_FILE_DATA_VALID - ); + NewFile->State = (UINT8) ~(EFI_FILE_HEADER_CONSTRUCTION | + EFI_FILE_HEADER_VALID | + EFI_FILE_DATA_VALID + ); *FfsFile = NewFile; @@ -1145,14 +1161,14 @@ FvBufPackageFreeformRawFile ( **/ EFI_STATUS FvBufFindNextSection ( - IN VOID *SectionsStart, - IN UINTN TotalSectionsSize, - IN OUT UINTN *Key, - OUT VOID **Section + IN VOID *SectionsStart, + IN UINTN TotalSectionsSize, + IN OUT UINTN *Key, + OUT VOID **Section ) { - EFI_COMMON_SECTION_HEADER *sectionHdr; - UINTN sectionSize; + EFI_COMMON_SECTION_HEADER *sectionHdr; + UINTN sectionSize; *Key = (UINTN)ALIGN_POINTER (*Key, 4); // Sections are DWORD aligned @@ -1160,7 +1176,7 @@ FvBufFindNextSection ( return EFI_NOT_FOUND; } - sectionHdr = (EFI_COMMON_SECTION_HEADER*)((UINT8*)SectionsStart + *Key); + sectionHdr = (EFI_COMMON_SECTION_HEADER *)((UINT8 *)SectionsStart + *Key); sectionSize = FvBufGetSecFileLen (sectionHdr); if (sectionSize < sizeof (EFI_COMMON_SECTION_HEADER)) { @@ -1171,10 +1187,9 @@ FvBufFindNextSection ( return EFI_NOT_FOUND; } - *Section = (UINT8*)sectionHdr; - *Key = *Key + sectionSize; + *Section = (UINT8 *)sectionHdr; + *Key = *Key + sectionSize; return EFI_SUCCESS; - } /** @@ -1190,21 +1205,21 @@ FvBufFindNextSection ( **/ EFI_STATUS FvBufCountSections ( - IN VOID* FfsFile, - IN UINTN* Count + IN VOID *FfsFile, + IN UINTN *Count ) { EFI_STATUS Status; UINTN Key; - VOID* SectionStart; + VOID *SectionStart; UINTN TotalSectionsSize; - EFI_COMMON_SECTION_HEADER* NextSection; + EFI_COMMON_SECTION_HEADER *NextSection; - SectionStart = (VOID*)((UINTN)FfsFile + FvBufGetFfsHeaderSize(FfsFile)); + SectionStart = (VOID *)((UINTN)FfsFile + FvBufGetFfsHeaderSize (FfsFile)); TotalSectionsSize = - FvBufGetFfsFileSize ((EFI_FFS_FILE_HEADER*)FfsFile) - - FvBufGetFfsHeaderSize(FfsFile); - Key = 0; + FvBufGetFfsFileSize ((EFI_FFS_FILE_HEADER *)FfsFile) - + FvBufGetFfsHeaderSize (FfsFile); + Key = 0; *Count = 0; while (TRUE) { Status = FvBufFindNextSection ( @@ -1223,7 +1238,6 @@ FvBufCountSections ( // Increment the section counter // *Count += 1; - } return EFI_NOT_FOUND; @@ -1245,21 +1259,21 @@ FvBufCountSections ( **/ EFI_STATUS FvBufFindSectionByType ( - IN VOID *FfsFile, - IN UINT8 Type, - OUT VOID **Section + IN VOID *FfsFile, + IN UINT8 Type, + OUT VOID **Section ) { - EFI_STATUS Status; - UINTN Key; - VOID* SectionStart; + EFI_STATUS Status; + UINTN Key; + VOID *SectionStart; UINTN TotalSectionsSize; - EFI_COMMON_SECTION_HEADER* NextSection; + EFI_COMMON_SECTION_HEADER *NextSection; - SectionStart = (VOID*)((UINTN)FfsFile + FvBufGetFfsHeaderSize(FfsFile)); + SectionStart = (VOID *)((UINTN)FfsFile + FvBufGetFfsHeaderSize (FfsFile)); TotalSectionsSize = - FvBufGetFfsFileSize ((EFI_FFS_FILE_HEADER*)FfsFile) - - FvBufGetFfsHeaderSize(FfsFile); + FvBufGetFfsFileSize ((EFI_FFS_FILE_HEADER *)FfsFile) - + FvBufGetFfsHeaderSize (FfsFile); Key = 0; while (TRUE) { Status = FvBufFindNextSection ( @@ -1276,6 +1290,7 @@ FvBufFindSectionByType ( if (Section != NULL) { *Section = NextSection; } + return EFI_SUCCESS; } } @@ -1291,23 +1306,23 @@ FvBufFindSectionByType ( end of the extended FV. @param Fv Firmware volume. - + @retval EFI_SUCCESS **/ EFI_STATUS FvBufShrinkWrap ( - IN VOID *Fv + IN VOID *Fv ) { - EFI_STATUS Status; - UINTN OldSize; - UINT32 BlockCount; - UINT32 NewBlockSize = 128; - UINTN Key; - EFI_FFS_FILE_HEADER* FileIt; - VOID* EndOfLastFile; + EFI_STATUS Status; + UINTN OldSize; + UINT32 BlockCount; + UINT32 NewBlockSize = 128; + UINTN Key; + EFI_FFS_FILE_HEADER *FileIt; + VOID *EndOfLastFile; - EFI_FIRMWARE_VOLUME_HEADER* FvHdr; + EFI_FIRMWARE_VOLUME_HEADER *FvHdr; Status = FvBufGetSize (Fv, &OldSize); if (EFI_ERROR (Status)) { @@ -1322,16 +1337,16 @@ FvBufShrinkWrap ( // // Locate the block map in the fv header // - FvHdr = (EFI_FIRMWARE_VOLUME_HEADER*)Fv; + FvHdr = (EFI_FIRMWARE_VOLUME_HEADER *)Fv; // // Find the end of the last file // - Key = 0; - EndOfLastFile = (UINT8*)FvHdr + FvHdr->FvLength; + Key = 0; + EndOfLastFile = (UINT8 *)FvHdr + FvHdr->FvLength; while (!EFI_ERROR (FvBufFindNextFile (Fv, &Key, (VOID **)&FileIt))) { EndOfLastFile = - (VOID*)((UINT8*)FileIt + FvBufGetFfsFileSize (FileIt)); + (VOID *)((UINT8 *)FileIt + FvBufGetFfsFileSize (FileIt)); } // @@ -1345,7 +1360,7 @@ FvBufShrinkWrap ( // Adjust the block count to shrink the Fv in place. // FvHdr->BlockMap[0].NumBlocks = BlockCount; - FvHdr->FvLength = BlockCount * NewBlockSize; + FvHdr->FvLength = BlockCount * NewBlockSize; // // Update the FV header checksum @@ -1353,7 +1368,6 @@ FvBufShrinkWrap ( FvBufChecksumHeader (Fv); return EFI_SUCCESS; - } /** @@ -1370,13 +1384,13 @@ FvBufShrinkWrap ( **/ EFI_STATUS FvBufUnifyBlockSizes ( - IN OUT VOID *Fv, - IN UINTN BlockSize + IN OUT VOID *Fv, + IN UINTN BlockSize ) { - EFI_FIRMWARE_VOLUME_HEADER *hdr = (EFI_FIRMWARE_VOLUME_HEADER*)Fv; - EFI_FV_BLOCK_MAP_ENTRY *blk = hdr->BlockMap; - UINT32 Size; + EFI_FIRMWARE_VOLUME_HEADER *hdr = (EFI_FIRMWARE_VOLUME_HEADER *)Fv; + EFI_FV_BLOCK_MAP_ENTRY *blk = hdr->BlockMap; + UINT32 Size; Size = 0; @@ -1384,12 +1398,13 @@ FvBufUnifyBlockSizes ( // Scan through the block map list, performing error checking, and adding // up the total Fv size. // - while( blk->Length != 0 || - blk->NumBlocks != 0 - ) { + while ( blk->Length != 0 || + blk->NumBlocks != 0 + ) + { Size = Size + (blk->Length * blk->NumBlocks); blk++; - if ((UINT8*)blk > ((UINT8*)hdr + hdr->HeaderLength)) { + if ((UINT8 *)blk > ((UINT8 *)hdr + hdr->HeaderLength)) { return EFI_VOLUME_CORRUPTED; } } @@ -1413,7 +1428,7 @@ FvBufUnifyBlockSizes ( // // Write out the single block map entry. // - hdr->BlockMap[0].Length = (UINT32)BlockSize; + hdr->BlockMap[0].Length = (UINT32)BlockSize; hdr->BlockMap[0].NumBlocks = Size / (UINT32)BlockSize; return EFI_SUCCESS; @@ -1430,8 +1445,8 @@ FvBufUnifyBlockSizes ( STATIC UINT16 FvBufCalculateSum16 ( - IN UINT16 *Buffer, - IN UINTN Size + IN UINT16 *Buffer, + IN UINTN Size ) { UINTN Index; @@ -1443,10 +1458,10 @@ FvBufCalculateSum16 ( // Perform the word sum for buffer // for (Index = 0; Index < Size; Index++) { - Sum = (UINT16) (Sum + Buffer[Index]); + Sum = (UINT16)(Sum + Buffer[Index]); } - return (UINT16) Sum; + return (UINT16)Sum; } /** @@ -1460,8 +1475,8 @@ FvBufCalculateSum16 ( STATIC UINT16 FvBufCalculateChecksum16 ( - IN UINT16 *Buffer, - IN UINTN Size + IN UINT16 *Buffer, + IN UINTN Size ) { return (UINT16)(0x10000 - FvBufCalculateSum16 (Buffer, Size)); @@ -1472,7 +1487,7 @@ FvBufCalculateChecksum16 ( @param Buffer Pointer to buffer containing byte data of component. @param Size Size of the buffer - + @return The 8 bit checksum value needed. **/ STATIC @@ -1482,8 +1497,8 @@ FvBufCalculateSum8 ( IN UINTN Size ) { - UINTN Index; - UINT8 Sum; + UINTN Index; + UINT8 Sum; Sum = 0; @@ -1491,7 +1506,7 @@ FvBufCalculateSum8 ( // Perform the byte sum for buffer // for (Index = 0; Index < Size; Index++) { - Sum = (UINT8) (Sum + Buffer[Index]); + Sum = (UINT8)(Sum + Buffer[Index]); } return Sum; @@ -1508,11 +1523,9 @@ FvBufCalculateSum8 ( STATIC UINT8 FvBufCalculateChecksum8 ( - IN UINT8 *Buffer, - IN UINTN Size + IN UINT8 *Buffer, + IN UINTN Size ) { return (UINT8)(0x100 - FvBufCalculateSum8 (Buffer, Size)); } - - diff --git a/BaseTools/Source/C/Common/FvLib.c b/BaseTools/Source/C/Common/FvLib.c index 37631f470f2a..f617ebdfde6d 100644 --- a/BaseTools/Source/C/Common/FvLib.c +++ b/BaseTools/Source/C/Common/FvLib.c @@ -16,8 +16,8 @@ SPDX-License-Identifier: BSD-2-Clause-Patent // // Module global variables // -EFI_FIRMWARE_VOLUME_HEADER *mFvHeader = NULL; -UINT32 mFvLength = 0; +EFI_FIRMWARE_VOLUME_HEADER *mFvHeader = NULL; +UINT32 mFvLength = 0; // // External function implementations @@ -35,8 +35,8 @@ UINT32 mFvLength = 0; **/ EFI_STATUS InitializeFvLib ( - IN VOID *Fv, - IN UINT32 FvLength + IN VOID *Fv, + IN UINT32 FvLength ) { // @@ -46,7 +46,7 @@ InitializeFvLib ( return EFI_INVALID_PARAMETER; } - mFvHeader = (EFI_FIRMWARE_VOLUME_HEADER *) Fv; + mFvHeader = (EFI_FIRMWARE_VOLUME_HEADER *)Fv; mFvLength = FvLength; return EFI_SUCCESS; @@ -71,9 +71,10 @@ GetFvHeader ( // // Verify library has been initialized. // - if (mFvHeader == NULL || mFvLength == 0) { + if ((mFvHeader == NULL) || (mFvLength == 0)) { return EFI_ABORTED; } + // // Verify input arguments // @@ -100,8 +101,8 @@ GetFvHeader ( **/ EFI_STATUS GetNextFile ( - IN EFI_FFS_FILE_HEADER *CurrentFile, - OUT EFI_FFS_FILE_HEADER **NextFile + IN EFI_FFS_FILE_HEADER *CurrentFile, + OUT EFI_FFS_FILE_HEADER **NextFile ) { EFI_STATUS Status; @@ -109,15 +110,17 @@ GetNextFile ( // // Verify library has been initialized. // - if (mFvHeader == NULL || mFvLength == 0) { + if ((mFvHeader == NULL) || (mFvLength == 0)) { return EFI_ABORTED; } + // // Verify input arguments // if (NextFile == NULL) { return EFI_INVALID_PARAMETER; } + // // Verify FV header // @@ -125,11 +128,12 @@ GetNextFile ( if (EFI_ERROR (Status)) { return EFI_ABORTED; } + // // Get first file // if (CurrentFile == NULL) { - CurrentFile = (EFI_FFS_FILE_HEADER *) ((UINTN) mFvHeader + mFvHeader->HeaderLength); + CurrentFile = (EFI_FFS_FILE_HEADER *)((UINTN)mFvHeader + mFvHeader->HeaderLength); // // Verify file is valid @@ -145,7 +149,7 @@ GetNextFile ( // // Verify file is in this FV. // - if ((UINTN) CurrentFile + GetFfsFileLength(CurrentFile) > (UINTN) mFvHeader + mFvLength) { + if ((UINTN)CurrentFile + GetFfsFileLength (CurrentFile) > (UINTN)mFvHeader + mFvLength) { *NextFile = NULL; return EFI_SUCCESS; } @@ -154,28 +158,33 @@ GetNextFile ( return EFI_SUCCESS; } } + // // Verify current file is in range // - if (((UINTN) CurrentFile < (UINTN) mFvHeader + mFvHeader->HeaderLength) || - ((UINTN) CurrentFile + GetFfsFileLength(CurrentFile) > (UINTN) mFvHeader + mFvLength) - ) { + if (((UINTN)CurrentFile < (UINTN)mFvHeader + mFvHeader->HeaderLength) || + ((UINTN)CurrentFile + GetFfsFileLength (CurrentFile) > (UINTN)mFvHeader + mFvLength) + ) + { return EFI_INVALID_PARAMETER; } + // // Get next file, compensate for 8 byte alignment if necessary. // - *NextFile = (EFI_FFS_FILE_HEADER *) ((((UINTN) CurrentFile - (UINTN) mFvHeader + GetFfsFileLength(CurrentFile) + 0x07) & (~(UINTN) 7)) + (UINT8 *) mFvHeader); + *NextFile = (EFI_FFS_FILE_HEADER *)((((UINTN)CurrentFile - (UINTN)mFvHeader + GetFfsFileLength (CurrentFile) + 0x07) & (~(UINTN)7)) + (UINT8 *)mFvHeader); // // Verify file is in this FV. // - if (((UINTN) *NextFile + GetFfsHeaderLength(*NextFile) >= (UINTN) mFvHeader + mFvLength) || - ((UINTN) *NextFile + GetFfsFileLength (*NextFile) > (UINTN) mFvHeader + mFvLength) - ) { + if (((UINTN)*NextFile + GetFfsHeaderLength (*NextFile) >= (UINTN)mFvHeader + mFvLength) || + ((UINTN)*NextFile + GetFfsFileLength (*NextFile) > (UINTN)mFvHeader + mFvLength) + ) + { *NextFile = NULL; return EFI_SUCCESS; } + // // Verify file is valid // @@ -203,26 +212,28 @@ GetNextFile ( **/ EFI_STATUS GetFileByName ( - IN EFI_GUID *FileName, - OUT EFI_FFS_FILE_HEADER **File + IN EFI_GUID *FileName, + OUT EFI_FFS_FILE_HEADER **File ) { - EFI_FFS_FILE_HEADER *CurrentFile; - EFI_STATUS Status; - CHAR8 FileGuidString[80]; + EFI_FFS_FILE_HEADER *CurrentFile; + EFI_STATUS Status; + CHAR8 FileGuidString[80]; // // Verify library has been initialized. // - if (mFvHeader == NULL || mFvLength == 0) { + if ((mFvHeader == NULL) || (mFvLength == 0)) { return EFI_ABORTED; } + // // Verify input parameters // - if (FileName == NULL || File == NULL) { + if ((FileName == NULL) || (File == NULL)) { return EFI_INVALID_PARAMETER; } + // // File Guid String Name // @@ -234,6 +245,7 @@ GetFileByName ( if (EFI_ERROR (Status)) { return EFI_ABORTED; } + // // Get the first file // @@ -242,6 +254,7 @@ GetFileByName ( Error (NULL, 0, 0003, "error parsing FV image", "FFS file with Guid %s can't be found", FileGuidString); return EFI_ABORTED; } + // // Loop as long as we have a valid file // @@ -257,6 +270,7 @@ GetFileByName ( return EFI_ABORTED; } } + // // File not found in this FV. // @@ -279,27 +293,29 @@ GetFileByName ( **/ EFI_STATUS GetFileByType ( - IN EFI_FV_FILETYPE FileType, - IN UINTN Instance, - OUT EFI_FFS_FILE_HEADER **File + IN EFI_FV_FILETYPE FileType, + IN UINTN Instance, + OUT EFI_FFS_FILE_HEADER **File ) { - EFI_FFS_FILE_HEADER *CurrentFile; - EFI_STATUS Status; - UINTN FileCount; + EFI_FFS_FILE_HEADER *CurrentFile; + EFI_STATUS Status; + UINTN FileCount; // // Verify library has been initialized. // - if (mFvHeader == NULL || mFvLength == 0) { + if ((mFvHeader == NULL) || (mFvLength == 0)) { return EFI_ABORTED; } + // // Verify input parameters // if (File == NULL) { return EFI_INVALID_PARAMETER; } + // // Verify FV header // @@ -307,6 +323,7 @@ GetFileByType ( if (EFI_ERROR (Status)) { return EFI_ABORTED; } + // // Initialize the number of matching files found. // @@ -320,11 +337,12 @@ GetFileByType ( Error (NULL, 0, 0003, "error parsing FV image", "FFS file with FileType 0x%x can't be found", FileType); return EFI_ABORTED; } + // // Loop as long as we have a valid file // while (CurrentFile) { - if (FileType == EFI_FV_FILETYPE_ALL || CurrentFile->Type == FileType) { + if ((FileType == EFI_FV_FILETYPE_ALL) || (CurrentFile->Type == FileType)) { FileCount++; } @@ -363,12 +381,12 @@ GetFileByType ( **/ EFI_STATUS SearchSectionByType ( - IN EFI_FILE_SECTION_POINTER FirstSection, - IN UINT8 *SearchEnd, - IN EFI_SECTION_TYPE SectionType, - IN OUT UINTN *StartIndex, - IN UINTN Instance, - OUT EFI_FILE_SECTION_POINTER *Section + IN EFI_FILE_SECTION_POINTER FirstSection, + IN UINT8 *SearchEnd, + IN EFI_SECTION_TYPE SectionType, + IN OUT UINTN *StartIndex, + IN UINTN Instance, + OUT EFI_FILE_SECTION_POINTER *Section ) { EFI_FILE_SECTION_POINTER CurrentSection; @@ -378,11 +396,11 @@ SearchSectionByType ( UINT16 GuidSecAttr; UINT16 GuidDataOffset; - GuidSecAttr = 0; + GuidSecAttr = 0; GuidDataOffset = 0; CurrentSection = FirstSection; - while ((UINTN) CurrentSection.CommonHeader < (UINTN) SearchEnd) { + while ((UINTN)CurrentSection.CommonHeader < (UINTN)SearchEnd) { if (CurrentSection.CommonHeader->Type == SectionType) { (*StartIndex)++; } @@ -391,6 +409,7 @@ SearchSectionByType ( *Section = CurrentSection; return EFI_SUCCESS; } + // // If the requesting section is not GUID-defined and // we find a GUID-defined section that doesn't need @@ -398,36 +417,39 @@ SearchSectionByType ( // section inside the GUID-defined section. // if (CurrentSection.CommonHeader->Type == EFI_SECTION_GUID_DEFINED) { - if (GetLength(CurrentSection.CommonHeader->Size) == 0xffffff) { - GuidSecAttr = CurrentSection.GuidDefinedSection2->Attributes; + if (GetLength (CurrentSection.CommonHeader->Size) == 0xffffff) { + GuidSecAttr = CurrentSection.GuidDefinedSection2->Attributes; GuidDataOffset = CurrentSection.GuidDefinedSection2->DataOffset; } else { - GuidSecAttr = CurrentSection.GuidDefinedSection->Attributes; + GuidSecAttr = CurrentSection.GuidDefinedSection->Attributes; GuidDataOffset = CurrentSection.GuidDefinedSection->DataOffset; } } - if (SectionType != EFI_SECTION_GUID_DEFINED && - CurrentSection.CommonHeader->Type == EFI_SECTION_GUID_DEFINED && - !(GuidSecAttr & EFI_GUIDED_SECTION_PROCESSING_REQUIRED)) { + + if ((SectionType != EFI_SECTION_GUID_DEFINED) && + (CurrentSection.CommonHeader->Type == EFI_SECTION_GUID_DEFINED) && + !(GuidSecAttr & EFI_GUIDED_SECTION_PROCESSING_REQUIRED)) + { InnerSection.CommonHeader = (EFI_COMMON_SECTION_HEADER *) - ((UINTN) CurrentSection.CommonHeader + GuidDataOffset); - SectionSize = GetSectionFileLength(CurrentSection.CommonHeader); - Status = SearchSectionByType ( - InnerSection, - (UINT8 *) ((UINTN) CurrentSection.CommonHeader + SectionSize), - SectionType, - StartIndex, - Instance, - Section - ); + ((UINTN)CurrentSection.CommonHeader + GuidDataOffset); + SectionSize = GetSectionFileLength (CurrentSection.CommonHeader); + Status = SearchSectionByType ( + InnerSection, + (UINT8 *)((UINTN)CurrentSection.CommonHeader + SectionSize), + SectionType, + StartIndex, + Instance, + Section + ); if (!EFI_ERROR (Status)) { return EFI_SUCCESS; } } + // // Find next section (including compensating for alignment issues. // - CurrentSection.CommonHeader = (EFI_COMMON_SECTION_HEADER *) ((((UINTN) CurrentSection.CommonHeader) + GetSectionFileLength(CurrentSection.CommonHeader) + 0x03) & (~(UINTN) 3)); + CurrentSection.CommonHeader = (EFI_COMMON_SECTION_HEADER *)((((UINTN)CurrentSection.CommonHeader) + GetSectionFileLength (CurrentSection.CommonHeader) + 0x03) & (~(UINTN)3)); } return EFI_NOT_FOUND; @@ -451,10 +473,10 @@ SearchSectionByType ( **/ EFI_STATUS GetSectionByType ( - IN EFI_FFS_FILE_HEADER *File, - IN EFI_SECTION_TYPE SectionType, - IN UINTN Instance, - OUT EFI_FILE_SECTION_POINTER *Section + IN EFI_FFS_FILE_HEADER *File, + IN EFI_SECTION_TYPE SectionType, + IN UINTN Instance, + OUT EFI_FILE_SECTION_POINTER *Section ) { EFI_FILE_SECTION_POINTER CurrentSection; @@ -464,9 +486,10 @@ GetSectionByType ( // // Verify input parameters // - if (File == NULL || Instance == 0) { + if ((File == NULL) || (Instance == 0)) { return EFI_INVALID_PARAMETER; } + // // Verify FFS header // @@ -475,6 +498,7 @@ GetSectionByType ( Error (NULL, 0, 0006, "invalid FFS file", NULL); return EFI_ABORTED; } + // // Initialize the number of matching sections found. // @@ -483,14 +507,14 @@ GetSectionByType ( // // Get the first section // - CurrentSection.CommonHeader = (EFI_COMMON_SECTION_HEADER *) ((UINTN) File + GetFfsHeaderLength(File)); + CurrentSection.CommonHeader = (EFI_COMMON_SECTION_HEADER *)((UINTN)File + GetFfsHeaderLength (File)); // // Depth-first manner to find section file. // Status = SearchSectionByType ( CurrentSection, - (UINT8 *) ((UINTN) File + GetFfsFileLength (File)), + (UINT8 *)((UINTN)File + GetFfsFileLength (File)), SectionType, &SectionCount, Instance, @@ -524,7 +548,7 @@ GetSectionByType ( **/ EFI_STATUS VerifyFv ( - IN EFI_FIRMWARE_VOLUME_HEADER *FvHeader + IN EFI_FIRMWARE_VOLUME_HEADER *FvHeader ) { UINT16 Checksum; @@ -540,10 +564,11 @@ VerifyFv ( Error (NULL, 0, 0006, "invalid FV header signature", NULL); return EFI_VOLUME_CORRUPTED; } + // // Verify header checksum // - Checksum = CalculateSum16 ((UINT16 *) FvHeader, FvHeader->HeaderLength / sizeof (UINT16)); + Checksum = CalculateSum16 ((UINT16 *)FvHeader, FvHeader->HeaderLength / sizeof (UINT16)); if (Checksum != 0) { Error (NULL, 0, 0006, "invalid FV header checksum", NULL); @@ -568,22 +593,23 @@ VerifyFfsFile ( IN EFI_FFS_FILE_HEADER *FfsHeader ) { - BOOLEAN ErasePolarity; - EFI_STATUS Status; - EFI_FFS_FILE_HEADER2 BlankHeader; - UINT8 Checksum; - UINT32 FileLength; - UINT8 SavedChecksum; - UINT8 SavedState; - UINT8 FileGuidString[80]; - UINT32 FfsHeaderSize; + BOOLEAN ErasePolarity; + EFI_STATUS Status; + EFI_FFS_FILE_HEADER2 BlankHeader; + UINT8 Checksum; + UINT32 FileLength; + UINT8 SavedChecksum; + UINT8 SavedState; + UINT8 FileGuidString[80]; + UINT32 FfsHeaderSize; // // Verify library has been initialized. // - if (mFvHeader == NULL || mFvLength == 0) { + if ((mFvHeader == NULL) || (mFvLength == 0)) { return EFI_ABORTED; } + // // Verify FV header // @@ -591,6 +617,7 @@ VerifyFfsFile ( if (EFI_ERROR (Status)) { return EFI_ABORTED; } + // // Get the erase polarity. // @@ -599,7 +626,7 @@ VerifyFfsFile ( return EFI_ABORTED; } - FfsHeaderSize = GetFfsHeaderLength(FfsHeader); + FfsHeaderSize = GetFfsHeaderLength (FfsHeader); // // Check if we have free space // @@ -612,6 +639,7 @@ VerifyFfsFile ( if (memcmp (&BlankHeader, FfsHeader, FfsHeaderSize) == 0) { return EFI_NOT_FOUND; } + // // Convert the GUID to a string so we can at least report which file // if we find an error. @@ -620,17 +648,18 @@ VerifyFfsFile ( // // Verify file header checksum // - SavedState = FfsHeader->State; - FfsHeader->State = 0; - SavedChecksum = FfsHeader->IntegrityCheck.Checksum.File; + SavedState = FfsHeader->State; + FfsHeader->State = 0; + SavedChecksum = FfsHeader->IntegrityCheck.Checksum.File; FfsHeader->IntegrityCheck.Checksum.File = 0; - Checksum = CalculateSum8 ((UINT8 *) FfsHeader, FfsHeaderSize); - FfsHeader->State = SavedState; + Checksum = CalculateSum8 ((UINT8 *)FfsHeader, FfsHeaderSize); + FfsHeader->State = SavedState; FfsHeader->IntegrityCheck.Checksum.File = SavedChecksum; if (Checksum != 0) { Error (NULL, 0, 0006, "invalid FFS file header checksum", "Ffs file with Guid %s", FileGuidString); return EFI_ABORTED; } + // // Verify file checksum // @@ -638,9 +667,9 @@ VerifyFfsFile ( // // Verify file data checksum // - FileLength = GetFfsFileLength (FfsHeader); - Checksum = CalculateSum8 ((UINT8 *) ((UINT8 *)FfsHeader + FfsHeaderSize), FileLength - FfsHeaderSize); - Checksum = Checksum + FfsHeader->IntegrityCheck.Checksum.File; + FileLength = GetFfsFileLength (FfsHeader); + Checksum = CalculateSum8 ((UINT8 *)((UINT8 *)FfsHeader + FfsHeaderSize), FileLength - FfsHeaderSize); + Checksum = Checksum + FfsHeader->IntegrityCheck.Checksum.File; if (Checksum != 0) { Error (NULL, 0, 0006, "invalid FFS file checksum", "Ffs file with Guid %s", FileGuidString); return EFI_ABORTED; @@ -660,31 +689,35 @@ VerifyFfsFile ( } UINT32 -GetFfsHeaderLength( - IN EFI_FFS_FILE_HEADER *FfsHeader - ) +GetFfsHeaderLength ( + IN EFI_FFS_FILE_HEADER *FfsHeader + ) { if (FfsHeader == NULL) { return 0; } + if (FfsHeader->Attributes & FFS_ATTRIB_LARGE_FILE) { - return sizeof(EFI_FFS_FILE_HEADER2); + return sizeof (EFI_FFS_FILE_HEADER2); } - return sizeof(EFI_FFS_FILE_HEADER); + + return sizeof (EFI_FFS_FILE_HEADER); } UINT32 -GetSectionHeaderLength( - IN EFI_COMMON_SECTION_HEADER *SectionHeader - ) +GetSectionHeaderLength ( + IN EFI_COMMON_SECTION_HEADER *SectionHeader + ) { if (SectionHeader == NULL) { return 0; } - if (GetLength(SectionHeader->Size) == 0xffffff) { - return sizeof(EFI_COMMON_SECTION_HEADER2); + + if (GetLength (SectionHeader->Size) == 0xffffff) { + return sizeof (EFI_COMMON_SECTION_HEADER2); } - return sizeof(EFI_COMMON_SECTION_HEADER); + + return sizeof (EFI_COMMON_SECTION_HEADER); } /** @@ -696,32 +729,36 @@ GetSectionHeaderLength( **/ UINT32 GetFfsFileLength ( - EFI_FFS_FILE_HEADER *FfsHeader + EFI_FFS_FILE_HEADER *FfsHeader ) { if (FfsHeader == NULL) { return 0; } + if (FfsHeader->Attributes & FFS_ATTRIB_LARGE_FILE) { - return (UINT32) ((EFI_FFS_FILE_HEADER2 *)FfsHeader)->ExtendedSize; + return (UINT32)((EFI_FFS_FILE_HEADER2 *)FfsHeader)->ExtendedSize; } else { - return GetLength(FfsHeader->Size); + return GetLength (FfsHeader->Size); } } UINT32 GetSectionFileLength ( - EFI_COMMON_SECTION_HEADER *SectionHeader + EFI_COMMON_SECTION_HEADER *SectionHeader ) { - UINT32 Length; + UINT32 Length; + if (SectionHeader == NULL) { return 0; } - Length = GetLength(SectionHeader->Size); + + Length = GetLength (SectionHeader->Size); if (Length == 0xffffff) { Length = ((EFI_COMMON_SECTION_HEADER2 *)SectionHeader)->ExtendedSize; } + return Length; } @@ -734,7 +771,7 @@ GetSectionFileLength ( **/ UINT32 GetLength ( - UINT8 *ThreeByteLength + UINT8 *ThreeByteLength ) { UINT32 Length; @@ -743,8 +780,8 @@ GetLength ( return 0; } - Length = *((UINT32 *) ThreeByteLength); - Length = Length & 0x00FFFFFF; + Length = *((UINT32 *)ThreeByteLength); + Length = Length & 0x00FFFFFF; return Length; } @@ -761,7 +798,7 @@ GetLength ( **/ EFI_STATUS GetErasePolarity ( - OUT BOOLEAN *ErasePolarity + OUT BOOLEAN *ErasePolarity ) { EFI_STATUS Status; @@ -769,9 +806,10 @@ GetErasePolarity ( // // Verify library has been initialized. // - if (mFvHeader == NULL || mFvLength == 0) { + if ((mFvHeader == NULL) || (mFvLength == 0)) { return EFI_ABORTED; } + // // Verify FV header // @@ -779,6 +817,7 @@ GetErasePolarity ( if (EFI_ERROR (Status)) { return EFI_ABORTED; } + // // Verify input parameters. // @@ -810,13 +849,13 @@ GetFileState ( IN EFI_FFS_FILE_HEADER *FfsHeader ) { - UINT8 FileState; - UINT8 HighestBit; + UINT8 FileState; + UINT8 HighestBit; FileState = FfsHeader->State; if (ErasePolarity) { - FileState = (UINT8)~FileState; + FileState = (UINT8) ~FileState; } HighestBit = 0x80; diff --git a/BaseTools/Source/C/Common/MemoryFile.c b/BaseTools/Source/C/Common/MemoryFile.c index 47481326833e..a96aa7ab8d44 100644 --- a/BaseTools/Source/C/Common/MemoryFile.c +++ b/BaseTools/Source/C/Common/MemoryFile.c @@ -13,14 +13,13 @@ SPDX-License-Identifier: BSD-2-Clause-Patent #include "CommonLib.h" #include "MemoryFile.h" - // // Local (static) function prototypes // STATIC VOID CheckMemoryFileState ( - IN EFI_HANDLE InputMemoryFile + IN EFI_HANDLE InputMemoryFile ); // @@ -39,14 +38,14 @@ CheckMemoryFileState ( **/ EFI_STATUS GetMemoryFile ( - IN CHAR8 *InputFileName, - OUT EFI_HANDLE *OutputMemoryFile + IN CHAR8 *InputFileName, + OUT EFI_HANDLE *OutputMemoryFile ) { - EFI_STATUS Status; - CHAR8 *InputFileImage; - UINT32 BytesRead; - MEMORY_FILE *NewMemoryFile; + EFI_STATUS Status; + CHAR8 *InputFileImage; + UINT32 BytesRead; + MEMORY_FILE *NewMemoryFile; Status = GetFileImage (InputFileName, &InputFileImage, &BytesRead); if (EFI_ERROR (Status)) { @@ -59,9 +58,9 @@ GetMemoryFile ( return EFI_OUT_OF_RESOURCES; } - NewMemoryFile->FileImage = InputFileImage; - NewMemoryFile->CurrentFilePointer = InputFileImage; - NewMemoryFile->Eof = InputFileImage + BytesRead; + NewMemoryFile->FileImage = InputFileImage; + NewMemoryFile->CurrentFilePointer = InputFileImage; + NewMemoryFile->Eof = InputFileImage + BytesRead; *OutputMemoryFile = (EFI_HANDLE)NewMemoryFile; @@ -79,14 +78,14 @@ GetMemoryFile ( **/ EFI_STATUS FreeMemoryFile ( - IN EFI_HANDLE InputMemoryFile + IN EFI_HANDLE InputMemoryFile ) { - MEMORY_FILE *MemoryFile; + MEMORY_FILE *MemoryFile; CheckMemoryFileState (InputMemoryFile); - MemoryFile = (MEMORY_FILE*)InputMemoryFile; + MemoryFile = (MEMORY_FILE *)InputMemoryFile; free (MemoryFile->FileImage); @@ -115,21 +114,21 @@ FreeMemoryFile ( **/ CHAR8 * ReadMemoryFileLine ( - IN EFI_HANDLE InputMemoryFile + IN EFI_HANDLE InputMemoryFile ) { - CHAR8 *EndOfLine; - UINTN CharsToCopy; - MEMORY_FILE *InputFile; - UINTN BytesToEof; - CHAR8 *OutputString; + CHAR8 *EndOfLine; + UINTN CharsToCopy; + MEMORY_FILE *InputFile; + UINTN BytesToEof; + CHAR8 *OutputString; // // Verify input parameters are not null // CheckMemoryFileState (InputMemoryFile); - InputFile = (MEMORY_FILE*)InputMemoryFile; + InputFile = (MEMORY_FILE *)InputMemoryFile; // // Check for end of file condition @@ -177,13 +176,9 @@ ReadMemoryFileLine ( // Add the null termination over the 0x0D // if (OutputString[CharsToCopy - 1] == '\r') { - OutputString[CharsToCopy - 1] = '\0'; - } else { - OutputString[CharsToCopy] = '\0'; - } // @@ -193,6 +188,7 @@ ReadMemoryFileLine ( if (InputFile->CurrentFilePointer > InputFile->Eof) { InputFile->CurrentFilePointer = InputFile->Eof; } + CheckMemoryFileState (InputMemoryFile); // @@ -201,18 +197,17 @@ ReadMemoryFileLine ( return OutputString; } - STATIC VOID CheckMemoryFileState ( - IN EFI_HANDLE InputMemoryFile + IN EFI_HANDLE InputMemoryFile ) { - MEMORY_FILE *MemoryFile; + MEMORY_FILE *MemoryFile; assert (InputMemoryFile != NULL); - MemoryFile = (MEMORY_FILE*)InputMemoryFile; + MemoryFile = (MEMORY_FILE *)InputMemoryFile; assert (MemoryFile->FileImage != NULL); assert (MemoryFile->CurrentFilePointer != NULL); @@ -221,5 +216,3 @@ CheckMemoryFileState ( assert (MemoryFile->CurrentFilePointer >= MemoryFile->FileImage); assert (MemoryFile->CurrentFilePointer <= MemoryFile->Eof); } - - diff --git a/BaseTools/Source/C/Common/MyAlloc.c b/BaseTools/Source/C/Common/MyAlloc.c index 17ff5cfbbd3e..2677f76c55cb 100644 --- a/BaseTools/Source/C/Common/MyAlloc.c +++ b/BaseTools/Source/C/Common/MyAlloc.c @@ -12,10 +12,10 @@ SPDX-License-Identifier: BSD-2-Clause-Patent // // Get back to original alloc/free calls. // -#undef malloc -#undef calloc -#undef realloc -#undef free + #undef malloc + #undef calloc + #undef realloc + #undef free // // Start of allocation list. // @@ -24,8 +24,8 @@ STATIC MY_ALLOC_STRUCT *MyAllocData = NULL; // // // -STATIC UINT32 MyAllocHeadMagik = MYALLOC_HEAD_MAGIK; -STATIC UINT32 MyAllocTailMagik = MYALLOC_TAIL_MAGIK; +STATIC UINT32 MyAllocHeadMagik = MYALLOC_HEAD_MAGIK; +STATIC UINT32 MyAllocTailMagik = MYALLOC_TAIL_MAGIK; /** Check for corruptions in the allocated memory chain. If a corruption @@ -40,12 +40,12 @@ STATIC UINT32 MyAllocTailMagik = MYALLOC_TAIL_MAGIK; **/ VOID MyCheck ( - BOOLEAN Final, - UINT8 File[], - UINTN Line + BOOLEAN Final, + UINT8 File[], + UINTN Line ) { - MY_ALLOC_STRUCT *Tmp; + MY_ALLOC_STRUCT *Tmp; // // Check parameters. @@ -84,34 +84,38 @@ MyCheck ( exit (1); } + // // Check structure contents. // for (Tmp = MyAllocData; Tmp != NULL; Tmp = Tmp->Next) { - if (memcmp(Tmp->Buffer, &MyAllocHeadMagik, sizeof MyAllocHeadMagik) || - memcmp(&Tmp->Buffer[Tmp->Size + sizeof(UINT32)], &MyAllocTailMagik, sizeof MyAllocTailMagik)) { + if (memcmp (Tmp->Buffer, &MyAllocHeadMagik, sizeof MyAllocHeadMagik) || + memcmp (&Tmp->Buffer[Tmp->Size + sizeof (UINT32)], &MyAllocTailMagik, sizeof MyAllocTailMagik)) + { break; } } + // // If Tmp is not NULL, the structure is corrupt. // if (Tmp != NULL) { printf ( - "\nMyCheck(Final=%u, File=%s, Line=%u)""\nStructure corrupted!" - "\nFile=%s, Line=%u, nSize=%u, Head=%xh, Tail=%xh\n", + "\nMyCheck(Final=%u, File=%s, Line=%u)" "\nStructure corrupted!" + "\nFile=%s, Line=%u, nSize=%u, Head=%xh, Tail=%xh\n", Final, File, (unsigned)Line, Tmp->File, - (unsigned) Tmp->Line, - (unsigned) Tmp->Size, - (unsigned) *(UINT32 *) (Tmp->Buffer), - (unsigned) *(UINT32 *) (&Tmp->Buffer[Tmp->Size + sizeof (UINT32)]) + (unsigned)Tmp->Line, + (unsigned)Tmp->Size, + (unsigned)*(UINT32 *)(Tmp->Buffer), + (unsigned)*(UINT32 *)(&Tmp->Buffer[Tmp->Size + sizeof (UINT32)]) ); exit (1); } + // // If Final is TRUE, display the state of the structure chain. // @@ -129,10 +133,10 @@ MyCheck ( printf ( "File=%s, Line=%u, nSize=%u, Head=%xh, Tail=%xh\n", Tmp->File, - (unsigned) Tmp->Line, - (unsigned) Tmp->Size, - (unsigned) *(UINT32 *) (Tmp->Buffer), - (unsigned) *(UINT32 *) (&Tmp->Buffer[Tmp->Size + sizeof (UINT32)]) + (unsigned)Tmp->Line, + (unsigned)Tmp->Size, + (unsigned)*(UINT32 *)(Tmp->Buffer), + (unsigned)*(UINT32 *)(&Tmp->Buffer[Tmp->Size + sizeof (UINT32)]) ); } } @@ -154,13 +158,13 @@ MyCheck ( **/ VOID * MyAlloc ( - UINTN Size, - UINT8 File[], - UINTN Line + UINTN Size, + UINT8 File[], + UINTN Line ) { - MY_ALLOC_STRUCT *Tmp; - UINTN Len; + MY_ALLOC_STRUCT *Tmp; + UINTN Len; // // Check for invalid parameters. @@ -176,7 +180,7 @@ MyAlloc ( exit (1); } - if (Size == 0 || Line == 0) { + if ((Size == 0) || (Line == 0)) { printf ( "\nMyAlloc(Size=%u, File=%s, Line=%u)" "\nInvalid parameter(s).\n", @@ -200,6 +204,7 @@ MyAlloc ( exit (1); } + // // Check the allocation list for corruption. // @@ -224,14 +229,15 @@ MyAlloc ( exit (1); } + // // Fill in the new entry. // - Tmp->File = ((UINT8 *) Tmp) + sizeof (MY_ALLOC_STRUCT); + Tmp->File = ((UINT8 *)Tmp) + sizeof (MY_ALLOC_STRUCT); strcpy ((CHAR8 *)Tmp->File, (CHAR8 *)File); Tmp->Line = Line; Tmp->Size = Size; - Tmp->Buffer = (UINT8 *) (((UINTN) Tmp + Len + 9) &~7); + Tmp->Buffer = (UINT8 *)(((UINTN)Tmp + Len + 9) &~7); memcpy (Tmp->Buffer, &MyAllocHeadMagik, sizeof MyAllocHeadMagik); @@ -241,8 +247,8 @@ MyAlloc ( sizeof MyAllocTailMagik ); - Tmp->Next = MyAllocData; - Tmp->Cksum = (UINTN) Tmp + (UINTN) (Tmp->Next) + Tmp->Line + Tmp->Size + (UINTN) (Tmp->File) + (UINTN) (Tmp->Buffer); + Tmp->Next = MyAllocData; + Tmp->Cksum = (UINTN)Tmp + (UINTN)(Tmp->Next) + Tmp->Line + Tmp->Size + (UINTN)(Tmp->File) + (UINTN)(Tmp->Buffer); MyAllocData = Tmp; @@ -263,14 +269,14 @@ MyAlloc ( **/ VOID * MyRealloc ( - VOID *Ptr, - UINTN Size, - UINT8 File[], - UINTN Line + VOID *Ptr, + UINTN Size, + UINT8 File[], + UINTN Line ) { - MY_ALLOC_STRUCT *Tmp; - VOID *Buffer; + MY_ALLOC_STRUCT *Tmp; + VOID *Buffer; // // Check for invalid parameter(s). @@ -287,7 +293,7 @@ MyRealloc ( exit (1); } - if (Size == 0 || Line == 0) { + if ((Size == 0) || (Line == 0)) { printf ( "\nMyRealloc(Ptr=%p, Size=%u, File=%s, Line=%u)" "\nInvalid parameter(s).\n", @@ -312,6 +318,7 @@ MyRealloc ( exit (1); } + // // Find existing buffer in allocation list. // @@ -320,7 +327,7 @@ MyRealloc ( } else if (&MyAllocData->Buffer[sizeof (UINT32)] == Ptr) { Tmp = MyAllocData; } else { - for (Tmp = MyAllocData;; Tmp = Tmp->Next) { + for (Tmp = MyAllocData; ; Tmp = Tmp->Next) { if (Tmp->Next == NULL) { printf ( "\nMyRealloc(Ptr=%p, Size=%u, File=%s, Line=%u)" @@ -337,12 +344,13 @@ MyRealloc ( Tmp = Tmp->Next; } } + // // Allocate new buffer, copy old data, free old buffer. // Buffer = MyAlloc (Size, File, Line); - if (Buffer != NULL && Tmp != NULL) { + if ((Buffer != NULL) && (Tmp != NULL)) { memcpy ( Buffer, &Tmp->Buffer[sizeof (UINT32)], @@ -366,13 +374,13 @@ MyRealloc ( **/ VOID MyFree ( - VOID *Ptr, - UINT8 File[], - UINTN Line + VOID *Ptr, + UINT8 File[], + UINTN Line ) { - MY_ALLOC_STRUCT *Tmp; - MY_ALLOC_STRUCT *Tmp2; + MY_ALLOC_STRUCT *Tmp; + MY_ALLOC_STRUCT *Tmp2; // // Check for invalid parameter(s). @@ -411,12 +419,14 @@ MyFree ( exit (1); } + // // Freeing NULL is always valid. // if (Ptr == NULL) { - return ; + return; } + // // Fail if nothing is allocated. // @@ -431,6 +441,7 @@ MyFree ( exit (1); } + // // Check for corrupted allocation list. // @@ -449,7 +460,7 @@ MyFree ( // // Walk list looking for matching item. // - for (Tmp = MyAllocData;; Tmp = Tmp->Next) { + for (Tmp = MyAllocData; ; Tmp = Tmp->Next) { // // Fail if end of list is reached. // @@ -464,6 +475,7 @@ MyFree ( exit (1); } + // // Leave loop when match is found. // @@ -471,6 +483,7 @@ MyFree ( break; } } + // // Unlink item from list. // @@ -478,6 +491,7 @@ MyFree ( Tmp->Next = Tmp->Next->Next; Tmp = Tmp2; } + // // Release item. // diff --git a/BaseTools/Source/C/Common/OsPath.c b/BaseTools/Source/C/Common/OsPath.c index 9901f686c98f..8e7614e24f5c 100644 --- a/BaseTools/Source/C/Common/OsPath.c +++ b/BaseTools/Source/C/Common/OsPath.c @@ -17,9 +17,9 @@ SPDX-License-Identifier: BSD-2-Clause-Patent // #if 0 - // - // BUGBUG: Not fully implemented yet. - // +// +// BUGBUG: Not fully implemented yet. +// /** This function returns the directory path which contains the particular path. @@ -38,17 +38,17 @@ SPDX-License-Identifier: BSD-2-Clause-Patent @return NULL if error **/ -CHAR8* +CHAR8 * OsPathDirName ( - IN CHAR8 *FilePath + IN CHAR8 *FilePath ) { - CHAR8 *Return; - CHAR8 *Pos; - CHAR8 Char; - UINTN Length; - INTN Offset; + CHAR8 *Return; + CHAR8 *Pos; + CHAR8 Char; + UINTN Length; + INTN Offset; Length = strlen (FilePath); @@ -60,9 +60,10 @@ OsPathDirName ( // Check for the root directory case // if ( - (Length == 3 && isalpha (FilePath[0]) && (strcmp(FilePath + 1, ":\\") == 0)) || - (strcmp(FilePath, "/") == 0) - ) { + ((Length == 3) && isalpha (FilePath[0]) && (strcmp (FilePath + 1, ":\\") == 0)) || + (strcmp (FilePath, "/") == 0) + ) + { return NULL; } @@ -70,7 +71,7 @@ OsPathDirName ( // If the path ends with a path separator, then just append ".." // Char = FilePath[Length - 1]; - if (Char == '/' || Char == '\\') { + if ((Char == '/') || (Char == '\\')) { return OsPathJoin (FilePath, ".."); } @@ -84,13 +85,13 @@ OsPathDirName ( } } } + #endif - #if 0 - // - // BUGBUG: Not fully implemented yet. - // +// +// BUGBUG: Not fully implemented yet. +// /** This function returns the directory path which contains the particular path. @@ -107,19 +108,19 @@ OsPathDirName ( **/ VOID OsPathNormPathInPlace ( - IN CHAR8 *Path + IN CHAR8 *Path ) { - CHAR8 *Pos; - INTN Offset; - BOOLEAN TryAgain; - UINTN Length; - UINTN Remaining; - UINTN SubLength; + CHAR8 *Pos; + INTN Offset; + BOOLEAN TryAgain; + UINTN Length; + UINTN Remaining; + UINTN SubLength; do { TryAgain = FALSE; - Length = strlen (Path); + Length = strlen (Path); for (Offset = 0; Offset < Length; Offset++) { Remaining = Length - Offset; @@ -131,7 +132,8 @@ OsPathNormPathInPlace ( (Remaining >= 2) && ((Offset > 0) || (Path[0] != '\\')) && IsDirSep (Path[Offset]) && IsDirSep (Path[Offset + 1]) - ) { + ) + { memmove (&Path[Offset], &Path[Offset + 1], Remaining); TryAgain = TRUE; break; @@ -141,8 +143,9 @@ OsPathNormPathInPlace ( // Collapse '/./' -> '/' // if ((Remaining >= 3) && IsDirSep (Path[Offset]) && - (Path[Offset + 1] == '.') && IsDirSep (Path[Offset + 2]) - ) { + (Path[Offset + 1] == '.') && IsDirSep (Path[Offset + 2]) + ) + { memmove (&Path[Offset], &Path[Offset + 1], Remaining); TryAgain = TRUE; break; @@ -152,9 +155,7 @@ OsPathNormPathInPlace ( // Collapse 'a/../b' -> 'b' // // BUGBUG: Not implemented yet - } - } while (TryAgain); Return = CloneString (FilePath); @@ -168,9 +169,10 @@ OsPathNormPathInPlace ( // Check for the root directory case // if ( - (Length == 3 && isalpha (Return[0]) && (strcmp(Return + 1, ":\\") == 0)) || - (strcmp(Return, "/") == 0) - ) { + ((Length == 3) && isalpha (Return[0]) && (strcmp (Return + 1, ":\\") == 0)) || + (strcmp (Return, "/") == 0) + ) + { free (Return); return NULL; } @@ -185,6 +187,7 @@ OsPathNormPathInPlace ( } } } + #endif /** @@ -202,16 +205,16 @@ OsPathNormPathInPlace ( @return A CHAR8* string, which must be freed by the caller **/ -CHAR8* +CHAR8 * OsPathPeerFilePath ( - IN CHAR8 *OldPath, - IN CHAR8 *Peer + IN CHAR8 *OldPath, + IN CHAR8 *Peer ) { - CHAR8 *Result; - INTN Offset; + CHAR8 *Result; + INTN Offset; - Result = (CHAR8 *) malloc (strlen (OldPath) + strlen (Peer) + 1); + Result = (CHAR8 *)malloc (strlen (OldPath) + strlen (Peer) + 1); if (Result == NULL) { return NULL; } @@ -247,10 +250,11 @@ OsPathPeerFilePath ( **/ BOOLEAN OsPathExists ( - IN CHAR8 *InputFileName + IN CHAR8 *InputFileName ) { - FILE *InputFile; + FILE *InputFile; + InputFile = fopen (LongFilePath (InputFileName), "rb"); if (InputFile == NULL) { return FALSE; @@ -259,6 +263,3 @@ OsPathExists ( return TRUE; } } - - - diff --git a/BaseTools/Source/C/Common/ParseGuidedSectionTools.c b/BaseTools/Source/C/Common/ParseGuidedSectionTools.c index e1e9a97e7bf6..566a22fe9036 100644 --- a/BaseTools/Source/C/Common/ParseGuidedSectionTools.c +++ b/BaseTools/Source/C/Common/ParseGuidedSectionTools.c @@ -17,16 +17,15 @@ SPDX-License-Identifier: BSD-2-Clause-Patent #include "ParseGuidedSectionTools.h" #include "StringFuncs.h" - // // Local types / structures // typedef struct _GUID_SEC_TOOL_ENTRY { - EFI_GUID Guid; - CHAR8* Name; - CHAR8* Path; - struct _GUID_SEC_TOOL_ENTRY *Next; + EFI_GUID Guid; + CHAR8 *Name; + CHAR8 *Path; + struct _GUID_SEC_TOOL_ENTRY *Next; } GUID_SEC_TOOL_ENTRY; // @@ -47,12 +46,12 @@ typedef struct _GUID_SEC_TOOL_ENTRY { **/ EFI_HANDLE ParseGuidedSectionToolsFile ( - IN CHAR8 *InputFile + IN CHAR8 *InputFile ) { - EFI_STATUS Status; - EFI_HANDLE MemoryFile; - EFI_HANDLE ParsedGuidedSectionTools; + EFI_STATUS Status; + EFI_HANDLE MemoryFile; + EFI_HANDLE ParsedGuidedSectionTools; Status = GetMemoryFile (InputFile, &MemoryFile); if (EFI_ERROR (Status)) { @@ -80,16 +79,16 @@ ParseGuidedSectionToolsFile ( **/ EFI_HANDLE ParseGuidedSectionToolsMemoryFile ( - IN EFI_HANDLE InputFile + IN EFI_HANDLE InputFile ) { - EFI_STATUS Status; - CHAR8 *NextLine; - STRING_LIST *Tool; - EFI_GUID Guid; - GUID_SEC_TOOL_ENTRY *FirstGuidTool; - GUID_SEC_TOOL_ENTRY *LastGuidTool; - GUID_SEC_TOOL_ENTRY *NewGuidTool; + EFI_STATUS Status; + CHAR8 *NextLine; + STRING_LIST *Tool; + EFI_GUID Guid; + GUID_SEC_TOOL_ENTRY *FirstGuidTool; + GUID_SEC_TOOL_ENTRY *LastGuidTool; + GUID_SEC_TOOL_ENTRY *NewGuidTool; FirstGuidTool = NULL; LastGuidTool = NULL; @@ -114,14 +113,15 @@ ParseGuidedSectionToolsMemoryFile ( Tool = SplitStringByWhitespace (NextLine); if ((Tool != NULL) && (Tool->Count == 3) - ) { + ) + { Status = StringToGuid (Tool->Strings[0], &Guid); if (!EFI_ERROR (Status)) { NewGuidTool = malloc (sizeof (GUID_SEC_TOOL_ENTRY)); if (NewGuidTool != NULL) { memcpy (&(NewGuidTool->Guid), &Guid, sizeof (Guid)); - NewGuidTool->Name = CloneString(Tool->Strings[1]); - NewGuidTool->Path = CloneString(Tool->Strings[2]); + NewGuidTool->Name = CloneString (Tool->Strings[1]); + NewGuidTool->Path = CloneString (Tool->Strings[2]); NewGuidTool->Next = NULL; if (FirstGuidTool == NULL) { @@ -129,6 +129,7 @@ ParseGuidedSectionToolsMemoryFile ( } else { LastGuidTool->Next = NewGuidTool; } + LastGuidTool = NewGuidTool; } } @@ -137,6 +138,7 @@ ParseGuidedSectionToolsMemoryFile ( if (Tool != NULL) { FreeStringList (Tool); } + free (NextLine); } @@ -154,15 +156,15 @@ ParseGuidedSectionToolsMemoryFile ( @retval Non-NULL The tool to use to access the section contents. (The caller must free the memory associated with this string.) **/ -CHAR8* +CHAR8 * LookupGuidedSectionToolPath ( - IN EFI_HANDLE ParsedGuidedSectionToolsHandle, - IN EFI_GUID *SectionGuid + IN EFI_HANDLE ParsedGuidedSectionToolsHandle, + IN EFI_GUID *SectionGuid ) { - GUID_SEC_TOOL_ENTRY *GuidTool; + GUID_SEC_TOOL_ENTRY *GuidTool; - GuidTool = (GUID_SEC_TOOL_ENTRY*)ParsedGuidedSectionToolsHandle; + GuidTool = (GUID_SEC_TOOL_ENTRY *)ParsedGuidedSectionToolsHandle; if (GuidTool == NULL) { return NULL; } @@ -175,5 +177,3 @@ LookupGuidedSectionToolPath ( return NULL; } - - diff --git a/BaseTools/Source/C/Common/ParseInf.c b/BaseTools/Source/C/Common/ParseInf.c index 63da3d647cb7..c8b4c07c3b05 100644 --- a/BaseTools/Source/C/Common/ParseInf.c +++ b/BaseTools/Source/C/Common/ParseInf.c @@ -31,15 +31,15 @@ SPDX-License-Identifier: BSD-2-Clause-Patent **/ CHAR8 * ReadLine ( - IN MEMORY_FILE *InputFile, - IN OUT CHAR8 *InputBuffer, - IN UINTN MaxLength + IN MEMORY_FILE *InputFile, + IN OUT CHAR8 *InputBuffer, + IN UINTN MaxLength ) { - CHAR8 *CharPtr; - CHAR8 *EndOfLine; - UINTN CharsToCopy; + CHAR8 *CharPtr; + CHAR8 *EndOfLine; + UINTN CharsToCopy; // // Verify input parameters are not null @@ -55,6 +55,7 @@ ReadLine ( if (InputFile->CurrentFilePointer >= InputFile->Eof) { return NULL; } + // // Find the next newline char // @@ -79,6 +80,7 @@ ReadLine ( // CharsToCopy = EndOfLine - InputFile->CurrentFilePointer; } + // // If the end of line is too big for the current buffer, set it to the max // size of the buffer (leaving room for the \0. @@ -86,6 +88,7 @@ ReadLine ( if (CharsToCopy > MaxLength - 1) { CharsToCopy = MaxLength - 1; } + // // Copy the line. // @@ -95,13 +98,9 @@ ReadLine ( // Add the null termination over the 0x0D // if (InputBuffer[CharsToCopy - 1] == '\r') { - InputBuffer[CharsToCopy - 1] = '\0'; - } else { - InputBuffer[CharsToCopy] = '\0'; - } // @@ -116,6 +115,7 @@ ReadLine ( if (CharPtr != 0) { CharPtr[0] = 0; } + // // Return the string // @@ -134,12 +134,12 @@ ReadLine ( **/ BOOLEAN FindSection ( - IN MEMORY_FILE *InputFile, - IN CHAR8 *Section + IN MEMORY_FILE *InputFile, + IN CHAR8 *Section ) { - CHAR8 InputBuffer[MAX_LONG_FILE_PATH]; - CHAR8 *CurrentToken; + CHAR8 InputBuffer[MAX_LONG_FILE_PATH]; + CHAR8 *CurrentToken; // // Verify input is not NULL @@ -192,39 +192,41 @@ FindSection ( **/ EFI_STATUS FindToken ( - IN MEMORY_FILE *InputFile, - IN CHAR8 *Section, - IN CHAR8 *Token, - IN UINTN Instance, - OUT CHAR8 *Value + IN MEMORY_FILE *InputFile, + IN CHAR8 *Section, + IN CHAR8 *Token, + IN UINTN Instance, + OUT CHAR8 *Value ) { - CHAR8 InputBuffer[MAX_LONG_FILE_PATH]; - CHAR8 *CurrentToken; - CHAR8 *Delimiter; - BOOLEAN ParseError; - BOOLEAN ReadError; - UINTN Occurrence; + CHAR8 InputBuffer[MAX_LONG_FILE_PATH]; + CHAR8 *CurrentToken; + CHAR8 *Delimiter; + BOOLEAN ParseError; + BOOLEAN ReadError; + UINTN Occurrence; // // Check input parameters // - if (InputFile->FileImage == NULL || - InputFile->Eof == NULL || - InputFile->CurrentFilePointer == NULL || - Section == NULL || - strlen (Section) == 0 || - Token == NULL || - strlen (Token) == 0 || - Value == NULL - ) { + if ((InputFile->FileImage == NULL) || + (InputFile->Eof == NULL) || + (InputFile->CurrentFilePointer == NULL) || + (Section == NULL) || + (strlen (Section) == 0) || + (Token == NULL) || + (strlen (Token) == 0) || + (Value == NULL) + ) + { return EFI_INVALID_PARAMETER; } + // // Initialize error codes // - ParseError = FALSE; - ReadError = FALSE; + ParseError = FALSE; + ReadError = FALSE; // // Initialize our instance counter for the search token @@ -246,6 +248,7 @@ FindToken ( ReadError = TRUE; break; } + // // Get the first non-whitespace string // @@ -255,19 +258,21 @@ FindToken ( } CurrentToken = strtok (InputBuffer, " \t\n"); - if (CurrentToken == NULL || Delimiter == NULL) { + if ((CurrentToken == NULL) || (Delimiter == NULL)) { // // Whitespace line found (or comment) so continue // CurrentToken = InputBuffer; continue; } + // // Make sure we have not reached the end of the current section // if (CurrentToken[0] == '[') { break; } + // // Compare the current token with the desired token // @@ -295,6 +300,7 @@ FindToken ( while (*CurrentToken == ' ' || *CurrentToken == '\t') { CurrentToken++; } + // // Copy the current token to the output value // @@ -302,9 +308,10 @@ FindToken ( // // Strip trailing white space // - while (strlen(Value) > 0 && (*(Value + strlen(Value) - 1) == ' ' || *(Value + strlen(Value) - 1) == '\t')) { - *(Value + strlen(Value) - 1) = 0; + while (strlen (Value) > 0 && (*(Value + strlen (Value) - 1) == ' ' || *(Value + strlen (Value) - 1) == '\t')) { + *(Value + strlen (Value) - 1) = 0; } + return EFI_SUCCESS; } } else { @@ -315,13 +322,14 @@ FindToken ( } } } while ( - !ParseError && - !ReadError && - InputFile->CurrentFilePointer < InputFile->Eof && - CurrentToken[0] != '[' && - Occurrence <= Instance - ); + !ParseError && + !ReadError && + InputFile->CurrentFilePointer < InputFile->Eof && + CurrentToken[0] != '[' && + Occurrence <= Instance + ); } + // // Distinguish between read errors and INF file format errors. // @@ -353,27 +361,29 @@ StringToGuid ( OUT EFI_GUID *GuidBuffer ) { - INT32 Index; - int Data1; - int Data2; - int Data3; - int Data4[8]; + INT32 Index; + int Data1; + int Data2; + int Data3; + int Data4[8]; - if (AsciiGuidBuffer == NULL || GuidBuffer == NULL) { + if ((AsciiGuidBuffer == NULL) || (GuidBuffer == NULL)) { return EFI_INVALID_PARAMETER; } + // // Check Guid Format strictly xxxxxxxx-xxxx-xxxx-xxxx-xxxxxxxxxxxx // - for (Index = 0; AsciiGuidBuffer[Index] != '\0' && Index < 37; Index ++) { - if (Index == 8 || Index == 13 || Index == 18 || Index == 23) { + for (Index = 0; AsciiGuidBuffer[Index] != '\0' && Index < 37; Index++) { + if ((Index == 8) || (Index == 13) || (Index == 18) || (Index == 23)) { if (AsciiGuidBuffer[Index] != '-') { break; } } else { if (((AsciiGuidBuffer[Index] >= '0') && (AsciiGuidBuffer[Index] <= '9')) || - ((AsciiGuidBuffer[Index] >= 'a') && (AsciiGuidBuffer[Index] <= 'f')) || - ((AsciiGuidBuffer[Index] >= 'A') && (AsciiGuidBuffer[Index] <= 'F'))) { + ((AsciiGuidBuffer[Index] >= 'a') && (AsciiGuidBuffer[Index] <= 'f')) || + ((AsciiGuidBuffer[Index] >= 'A') && (AsciiGuidBuffer[Index] <= 'F'))) + { continue; } else { break; @@ -381,7 +391,7 @@ StringToGuid ( } } - if (Index < 36 || AsciiGuidBuffer[36] != '\0') { + if ((Index < 36) || (AsciiGuidBuffer[36] != '\0')) { Error (NULL, 0, 1003, "Invalid option value", "Incorrect GUID \"%s\"\n Correct Format \"xxxxxxxx-xxxx-xxxx-xxxx-xxxxxxxxxxxx\"", AsciiGuidBuffer); return EFI_ABORTED; } @@ -412,20 +422,21 @@ StringToGuid ( Error (NULL, 0, 1003, "Invalid option value", "Incorrect GUID \"%s\"\n Correct Format \"xxxxxxxx-xxxx-xxxx-xxxx-xxxxxxxxxxxx\"", AsciiGuidBuffer); return EFI_ABORTED; } + // // Copy the data into our GUID. // - GuidBuffer->Data1 = (UINT32) Data1; - GuidBuffer->Data2 = (UINT16) Data2; - GuidBuffer->Data3 = (UINT16) Data3; - GuidBuffer->Data4[0] = (UINT8) Data4[0]; - GuidBuffer->Data4[1] = (UINT8) Data4[1]; - GuidBuffer->Data4[2] = (UINT8) Data4[2]; - GuidBuffer->Data4[3] = (UINT8) Data4[3]; - GuidBuffer->Data4[4] = (UINT8) Data4[4]; - GuidBuffer->Data4[5] = (UINT8) Data4[5]; - GuidBuffer->Data4[6] = (UINT8) Data4[6]; - GuidBuffer->Data4[7] = (UINT8) Data4[7]; + GuidBuffer->Data1 = (UINT32)Data1; + GuidBuffer->Data2 = (UINT16)Data2; + GuidBuffer->Data3 = (UINT16)Data3; + GuidBuffer->Data4[0] = (UINT8)Data4[0]; + GuidBuffer->Data4[1] = (UINT8)Data4[1]; + GuidBuffer->Data4[2] = (UINT8)Data4[2]; + GuidBuffer->Data4[3] = (UINT8)Data4[3]; + GuidBuffer->Data4[4] = (UINT8)Data4[4]; + GuidBuffer->Data4[5] = (UINT8)Data4[5]; + GuidBuffer->Data4[6] = (UINT8)Data4[6]; + GuidBuffer->Data4[7] = (UINT8)Data4[7]; return EFI_SUCCESS; } @@ -463,11 +474,12 @@ AsciiStringToUint64 ( // // Check input parameter // - if (AsciiString == NULL || ReturnValue == NULL || strlen(AsciiString) > 0xFF) { + if ((AsciiString == NULL) || (ReturnValue == NULL) || (strlen (AsciiString) > 0xFF)) { return EFI_INVALID_PARAMETER; } + while (AsciiString[Index] == ' ') { - Index ++; + Index++; } // @@ -477,34 +489,37 @@ AsciiStringToUint64 ( // // Skip first two chars only if the string starts with '0x' or '0X' // - if (AsciiString[Index] == '0' && (AsciiString[Index + 1] == 'x' || AsciiString[Index + 1] == 'X')) { - IsHex = TRUE; + if ((AsciiString[Index] == '0') && ((AsciiString[Index + 1] == 'x') || (AsciiString[Index + 1] == 'X'))) { + IsHex = TRUE; Index += 2; } + if (IsHex) { // // Convert the hex string. // - for (; AsciiString[Index] != '\0'; Index++) { + for ( ; AsciiString[Index] != '\0'; Index++) { CurrentChar = AsciiString[Index]; if (CurrentChar == ' ') { break; } + // // Verify Hex string // if (isxdigit ((int)CurrentChar) == 0) { return EFI_ABORTED; } + // // Add hex value // Value *= 16; - if (CurrentChar >= '0' && CurrentChar <= '9') { + if ((CurrentChar >= '0') && (CurrentChar <= '9')) { Value += CurrentChar - '0'; - } else if (CurrentChar >= 'a' && CurrentChar <= 'f') { + } else if ((CurrentChar >= 'a') && (CurrentChar <= 'f')) { Value += CurrentChar - 'a' + 10; - } else if (CurrentChar >= 'A' && CurrentChar <= 'F') { + } else if ((CurrentChar >= 'A') && (CurrentChar <= 'F')) { Value += CurrentChar - 'A' + 10; } } @@ -514,21 +529,23 @@ AsciiStringToUint64 ( // // Convert dec string is a number // - for (; Index < strlen (AsciiString); Index++) { + for ( ; Index < strlen (AsciiString); Index++) { CurrentChar = AsciiString[Index]; if (CurrentChar == ' ') { break; } + // // Verify Dec string // if (isdigit ((int)CurrentChar) == 0) { return EFI_ABORTED; } + // // Add dec value // - Value = Value * 10; + Value = Value * 10; Value += CurrentChar - '0'; } @@ -554,7 +571,7 @@ ReadLineInStream ( IN OUT CHAR8 *InputBuffer ) { - CHAR8 *CharPtr; + CHAR8 *CharPtr; // // Verify input parameters are not null @@ -568,6 +585,7 @@ ReadLineInStream ( if (fgets (InputBuffer, MAX_LONG_FILE_PATH, InputFile) == NULL) { return NULL; } + // // Strip any comments // @@ -580,6 +598,7 @@ ReadLineInStream ( if (CharPtr != 0) { CharPtr[0] = 0; } + // // Return the string // @@ -599,12 +618,12 @@ ReadLineInStream ( **/ BOOLEAN FindSectionInStream ( - IN FILE *InputFile, - IN CHAR8 *Section + IN FILE *InputFile, + IN CHAR8 *Section ) { - CHAR8 InputBuffer[MAX_LONG_FILE_PATH]; - CHAR8 *CurrentToken; + CHAR8 InputBuffer[MAX_LONG_FILE_PATH]; + CHAR8 *CurrentToken; // // Verify input is not NULL @@ -618,6 +637,7 @@ FindSectionInStream ( if (fseek (InputFile, 0, SEEK_SET) != 0) { return FALSE; } + // // Read lines until the section is found // diff --git a/BaseTools/Source/C/Common/PcdValueCommon.c b/BaseTools/Source/C/Common/PcdValueCommon.c index 591a7787828c..d93924132e68 100644 --- a/BaseTools/Source/C/Common/PcdValueCommon.c +++ b/BaseTools/Source/C/Common/PcdValueCommon.c @@ -23,13 +23,13 @@ typedef enum { } PCD_DATA_TYPE; typedef struct { - CHAR8 *SkuName; - CHAR8 *DefaultValueName; - CHAR8 *TokenSpaceGuidName; - CHAR8 *TokenName; - CHAR8 *DataType; - CHAR8 *Value; - PCD_DATA_TYPE PcdDataType; + CHAR8 *SkuName; + CHAR8 *DefaultValueName; + CHAR8 *TokenSpaceGuidName; + CHAR8 *TokenName; + CHAR8 *DataType; + CHAR8 *Value; + PCD_DATA_TYPE PcdDataType; } PCD_ENTRY; PCD_ENTRY *PcdList; @@ -61,43 +61,45 @@ RecordToken ( if (Token == NULL) { return; } + memcpy (Token, &FileBuffer[TokenStart], TokenEnd - TokenStart); Token[TokenEnd - TokenStart] = 0; switch (TokenIndex) { - case 0: - PcdList[PcdIndex].SkuName = Token; - break; - case 1: - PcdList[PcdIndex].DefaultValueName = Token; - break; - case 2: - PcdList[PcdIndex].TokenSpaceGuidName = Token; - break; - case 3: - PcdList[PcdIndex].TokenName = Token; - break; - case 4: - PcdList[PcdIndex].DataType = Token; - if (strcmp (Token, "BOOLEAN") == 0) { - PcdList[PcdIndex].PcdDataType = PcdDataTypeBoolean; - } else if (strcmp (Token, "UINT8") == 0) { - PcdList[PcdIndex].PcdDataType = PcdDataTypeUint8; - } else if (strcmp (Token, "UINT16") == 0) { - PcdList[PcdIndex].PcdDataType = PcdDataTypeUint16; - } else if (strcmp (Token, "UINT32") == 0) { - PcdList[PcdIndex].PcdDataType = PcdDataTypeUint32; - } else if (strcmp (Token, "UINT64") == 0) { - PcdList[PcdIndex].PcdDataType = PcdDataTypeUint64; - } else { - PcdList[PcdIndex].PcdDataType = PcdDataTypePointer; - } - break; - case 5: - PcdList[PcdIndex].Value = Token; - break; - default: - free (Token); - break; + case 0: + PcdList[PcdIndex].SkuName = Token; + break; + case 1: + PcdList[PcdIndex].DefaultValueName = Token; + break; + case 2: + PcdList[PcdIndex].TokenSpaceGuidName = Token; + break; + case 3: + PcdList[PcdIndex].TokenName = Token; + break; + case 4: + PcdList[PcdIndex].DataType = Token; + if (strcmp (Token, "BOOLEAN") == 0) { + PcdList[PcdIndex].PcdDataType = PcdDataTypeBoolean; + } else if (strcmp (Token, "UINT8") == 0) { + PcdList[PcdIndex].PcdDataType = PcdDataTypeUint8; + } else if (strcmp (Token, "UINT16") == 0) { + PcdList[PcdIndex].PcdDataType = PcdDataTypeUint16; + } else if (strcmp (Token, "UINT32") == 0) { + PcdList[PcdIndex].PcdDataType = PcdDataTypeUint32; + } else if (strcmp (Token, "UINT64") == 0) { + PcdList[PcdIndex].PcdDataType = PcdDataTypeUint64; + } else { + PcdList[PcdIndex].PcdDataType = PcdDataTypePointer; + } + + break; + case 5: + PcdList[PcdIndex].Value = Token; + break; + default: + free (Token); + break; } } @@ -125,24 +127,31 @@ LookupPcdIndex ( if (SkuName == NULL) { SkuName = "DEFAULT"; } + if (DefaultValueName == NULL) { DefaultValueName = "DEFAULT"; } + for (Index = 0; Index < PcdListLength; Index++) { - if (strcmp(PcdList[Index].TokenSpaceGuidName, TokenSpaceGuidName) != 0) { + if (strcmp (PcdList[Index].TokenSpaceGuidName, TokenSpaceGuidName) != 0) { continue; } - if (strcmp(PcdList[Index].TokenName, TokenName) != 0) { + + if (strcmp (PcdList[Index].TokenName, TokenName) != 0) { continue; } - if (strcmp(PcdList[Index].SkuName, SkuName) != 0) { + + if (strcmp (PcdList[Index].SkuName, SkuName) != 0) { continue; } - if (strcmp(PcdList[Index].DefaultValueName, DefaultValueName) != 0) { + + if (strcmp (PcdList[Index].DefaultValueName, DefaultValueName) != 0) { continue; } + return Index; } + return -1; } @@ -172,21 +181,23 @@ __PcdGet ( fprintf (stderr, "PCD %s.%s.%s.%s is not in database\n", SkuName, DefaultValueName, TokenSpaceGuidName, TokenName); exit (EXIT_FAILURE); } + switch (PcdList[Index].PcdDataType) { - case PcdDataTypeBoolean: - case PcdDataTypeUint8: - case PcdDataTypeUint16: - case PcdDataTypeUint32: - return (UINT64)strtoul(PcdList[Index].Value, &End, 16); - break; - case PcdDataTypeUint64: - return (UINT64)strtoul(PcdList[Index].Value, &End, 16); - break; - case PcdDataTypePointer: - fprintf (stderr, "PCD %s.%s.%s.%s is structure. Use PcdGetPtr()\n", SkuName, DefaultValueName, TokenSpaceGuidName, TokenName); - exit (EXIT_FAILURE); - break; + case PcdDataTypeBoolean: + case PcdDataTypeUint8: + case PcdDataTypeUint16: + case PcdDataTypeUint32: + return (UINT64)strtoul (PcdList[Index].Value, &End, 16); + break; + case PcdDataTypeUint64: + return (UINT64)strtoul (PcdList[Index].Value, &End, 16); + break; + case PcdDataTypePointer: + fprintf (stderr, "PCD %s.%s.%s.%s is structure. Use PcdGetPtr()\n", SkuName, DefaultValueName, TokenSpaceGuidName, TokenName); + exit (EXIT_FAILURE); + break; } + return 0; } @@ -208,39 +219,41 @@ __PcdSet ( UINT64 Value ) { - int Index; + int Index; Index = LookupPcdIndex (SkuName, DefaultValueName, TokenSpaceGuidName, TokenName); if (Index < 0) { fprintf (stderr, "PCD %s.%s.%s.%s is not in database\n", SkuName, DefaultValueName, TokenSpaceGuidName, TokenName); exit (EXIT_FAILURE); } - free(PcdList[Index].Value); - PcdList[Index].Value = malloc(20); + + free (PcdList[Index].Value); + PcdList[Index].Value = malloc (20); switch (PcdList[Index].PcdDataType) { - case PcdDataTypeBoolean: - if (Value == 0) { - strcpy (PcdList[Index].Value, "0x00"); - } else { - strcpy (PcdList[Index].Value, "0x01"); - } - break; - case PcdDataTypeUint8: - sprintf(PcdList[Index].Value, "0x%02x", (UINT8)(Value & 0xff)); - break; - case PcdDataTypeUint16: - sprintf(PcdList[Index].Value, "0x%04x", (UINT16)(Value & 0xffff)); - break; - case PcdDataTypeUint32: - sprintf(PcdList[Index].Value, "0x%08x", (UINT32)(Value & 0xffffffff)); - break; - case PcdDataTypeUint64: - sprintf(PcdList[Index].Value, "0x%016llx", (unsigned long long)Value); - break; - case PcdDataTypePointer: - fprintf (stderr, "PCD %s.%s.%s.%s is structure. Use PcdSetPtr()\n", SkuName, DefaultValueName, TokenSpaceGuidName, TokenName); - exit (EXIT_FAILURE); - break; + case PcdDataTypeBoolean: + if (Value == 0) { + strcpy (PcdList[Index].Value, "0x00"); + } else { + strcpy (PcdList[Index].Value, "0x01"); + } + + break; + case PcdDataTypeUint8: + sprintf (PcdList[Index].Value, "0x%02x", (UINT8)(Value & 0xff)); + break; + case PcdDataTypeUint16: + sprintf (PcdList[Index].Value, "0x%04x", (UINT16)(Value & 0xffff)); + break; + case PcdDataTypeUint32: + sprintf (PcdList[Index].Value, "0x%08x", (UINT32)(Value & 0xffffffff)); + break; + case PcdDataTypeUint64: + sprintf (PcdList[Index].Value, "0x%016llx", (unsigned long long)Value); + break; + case PcdDataTypePointer: + fprintf (stderr, "PCD %s.%s.%s.%s is structure. Use PcdSetPtr()\n", SkuName, DefaultValueName, TokenSpaceGuidName, TokenName); + exit (EXIT_FAILURE); + break; } } @@ -252,7 +265,7 @@ __PcdSet ( @param TokenSpaceGuidName TokenSpaceGuidName String @param TokenName TokenName String @param Size Size of PCD value buffer - + @return PCD value buffer **/ VOID * @@ -265,40 +278,45 @@ __PcdGetPtr ( ) { int Index; - CHAR8 *Value; - UINT8 *Buffer; - CHAR8 *End; + CHAR8 *Value; + UINT8 *Buffer; + CHAR8 *End; Index = LookupPcdIndex (SkuName, DefaultValueName, TokenSpaceGuidName, TokenName); if (Index < 0) { fprintf (stderr, "PCD %s.%s.%s.%s is not in database\n", SkuName, DefaultValueName, TokenSpaceGuidName, TokenName); exit (EXIT_FAILURE); } + switch (PcdList[Index].PcdDataType) { - case PcdDataTypeBoolean: - case PcdDataTypeUint8: - case PcdDataTypeUint16: - case PcdDataTypeUint32: - case PcdDataTypeUint64: - fprintf (stderr, "PCD %s.%s.%s.%s is a value. Use PcdGet()\n", SkuName, DefaultValueName, TokenSpaceGuidName, TokenName); - exit (EXIT_FAILURE); - break; - case PcdDataTypePointer: - Value = &PcdList[Index].Value[1]; - for (*Size = 0, strtoul(Value, &End, 16); Value != End; strtoul(Value, &End, 16), *Size = *Size + 1) { - Value = End + 1; - } - Buffer = malloc(*Size + 1); - if (Buffer == NULL) { - *Size = 0; - return NULL; - } - Value = &PcdList[Index].Value[1]; - for (*Size = 0, Buffer[*Size] = (UINT8) strtoul(Value, &End, 16); Value != End; *Size = *Size + 1, Buffer[*Size] = (UINT8) strtoul(Value, &End, 16)) { - Value = End + 1; - } - return Buffer; + case PcdDataTypeBoolean: + case PcdDataTypeUint8: + case PcdDataTypeUint16: + case PcdDataTypeUint32: + case PcdDataTypeUint64: + fprintf (stderr, "PCD %s.%s.%s.%s is a value. Use PcdGet()\n", SkuName, DefaultValueName, TokenSpaceGuidName, TokenName); + exit (EXIT_FAILURE); + break; + case PcdDataTypePointer: + Value = &PcdList[Index].Value[1]; + for (*Size = 0, strtoul (Value, &End, 16); Value != End; strtoul (Value, &End, 16), *Size = *Size + 1) { + Value = End + 1; + } + + Buffer = malloc (*Size + 1); + if (Buffer == NULL) { + *Size = 0; + return NULL; + } + + Value = &PcdList[Index].Value[1]; + for (*Size = 0, Buffer[*Size] = (UINT8)strtoul (Value, &End, 16); Value != End; *Size = *Size + 1, Buffer[*Size] = (UINT8)strtoul (Value, &End, 16)) { + Value = End + 1; + } + + return Buffer; } + *Size = 0; return 0; } @@ -323,7 +341,7 @@ __PcdSetPtr ( UINT8 *Value ) { - int Index; + int Index; UINT32 ValueIndex; Index = LookupPcdIndex (SkuName, DefaultValueName, TokenSpaceGuidName, TokenName); @@ -331,31 +349,33 @@ __PcdSetPtr ( fprintf (stderr, "PCD %s.%s.%s.%s is not in database\n", SkuName, DefaultValueName, TokenSpaceGuidName, TokenName); exit (EXIT_FAILURE); } + switch (PcdList[Index].PcdDataType) { - case PcdDataTypeBoolean: - case PcdDataTypeUint8: - case PcdDataTypeUint16: - case PcdDataTypeUint32: - case PcdDataTypeUint64: - fprintf (stderr, "PCD %s.%s.%s.%s is a value. Use PcdGet()\n", SkuName, DefaultValueName, TokenSpaceGuidName, TokenName); - exit (EXIT_FAILURE); - break; - case PcdDataTypePointer: - free(PcdList[Index].Value); - PcdList[Index].Value = malloc(Size * 5 + 3); - PcdList[Index].Value[0] = '{'; - for (ValueIndex = 0; ValueIndex < Size; ValueIndex++) { - sprintf(&PcdList[Index].Value[1 + ValueIndex * 5], "0x%02x,", Value[ValueIndex]); - } - PcdList[Index].Value[1 + Size * 5 - 1] = '}'; - PcdList[Index].Value[1 + Size * 5 ] = 0; - break; + case PcdDataTypeBoolean: + case PcdDataTypeUint8: + case PcdDataTypeUint16: + case PcdDataTypeUint32: + case PcdDataTypeUint64: + fprintf (stderr, "PCD %s.%s.%s.%s is a value. Use PcdGet()\n", SkuName, DefaultValueName, TokenSpaceGuidName, TokenName); + exit (EXIT_FAILURE); + break; + case PcdDataTypePointer: + free (PcdList[Index].Value); + PcdList[Index].Value = malloc (Size * 5 + 3); + PcdList[Index].Value[0] = '{'; + for (ValueIndex = 0; ValueIndex < Size; ValueIndex++) { + sprintf (&PcdList[Index].Value[1 + ValueIndex * 5], "0x%02x,", Value[ValueIndex]); + } + + PcdList[Index].Value[1 + Size * 5 - 1] = '}'; + PcdList[Index].Value[1 + Size * 5] = 0; + break; } } /** Read the file buffer from the input file. - + @param InputFileName Point to the input file name. @param FileBuffer Point to the input file buffer. @param FileSize Size of the file buffer. @@ -459,15 +479,17 @@ ParseFile ( NumLines++; } } - PcdList = malloc((NumLines + 1) * sizeof(PcdList[0])); + + PcdList = malloc ((NumLines + 1) * sizeof (PcdList[0])); for (Index = 0, TokenIndex = 0, PcdListLength = 0, TokenStart = 0; Index < FileSize; Index++) { if (FileBuffer[Index] == ' ') { continue; } - if (FileBuffer[Index] == '|' || FileBuffer[Index] == '.' || FileBuffer[Index] == '\n' || FileBuffer[Index] == '\r') { + + if ((FileBuffer[Index] == '|') || (FileBuffer[Index] == '.') || (FileBuffer[Index] == '\n') || (FileBuffer[Index] == '\r')) { RecordToken (FileBuffer, PcdListLength, TokenIndex, TokenStart, Index); - if (FileBuffer[Index] == '\n' || FileBuffer[Index] == '\r') { + if ((FileBuffer[Index] == '\n') || (FileBuffer[Index] == '\r')) { if (TokenIndex != 0) { PcdListLength++; TokenIndex = 0; @@ -475,10 +497,12 @@ ParseFile ( } else { TokenIndex++; } + TokenStart = Index + 1; continue; } } + if (Index > TokenStart) { RecordToken (FileBuffer, PcdListLength, TokenIndex, TokenStart, Index); if (TokenIndex != 0) { @@ -495,7 +519,7 @@ ParseFile ( VOID STATIC WriteOutputFile ( - CHAR8 *OutputFileName + CHAR8 *OutputFileName ) { FILE *OutputFile; @@ -584,24 +608,26 @@ ParseArguments ( while (argc > 0) { if ((stricmp (argv[0], "-i") == 0) || (stricmp (argv[0], "--input") == 0)) { - if (argv[1] == NULL || argv[1][0] == '-') { + if ((argv[1] == NULL) || (argv[1][0] == '-')) { fprintf (stderr, "Invalid option value. Input File name is missing for -i option\n"); exit (EXIT_FAILURE); } + *InputFileName = argv[1]; - argc -= 2; - argv += 2; + argc -= 2; + argv += 2; continue; } if ((stricmp (argv[0], "-o") == 0) || (stricmp (argv[0], "--output") == 0)) { - if (argv[1] == NULL || argv[1][0] == '-') { + if ((argv[1] == NULL) || (argv[1][0] == '-')) { fprintf (stderr, "Invalid option value. Output File name is missing for -i option\n"); exit (EXIT_FAILURE); } + *OutputFileName = argv[1]; - argc -= 2; - argv += 2; + argc -= 2; + argv += 2; continue; } @@ -609,8 +635,9 @@ ParseArguments ( fprintf (stderr, "Unknown option %s\n", argv[0]); exit (EXIT_FAILURE); } - argc --; - argv ++; + + argc--; + argv++; } // @@ -646,7 +673,7 @@ PcdValueMain ( UINT8 *FileBuffer; UINT32 FileSize; - InputFileName = NULL; + InputFileName = NULL; OutputFileName = NULL; // diff --git a/BaseTools/Source/C/Common/PeCoffLoaderEx.c b/BaseTools/Source/C/Common/PeCoffLoaderEx.c index 181192035ef1..5865b825357c 100644 --- a/BaseTools/Source/C/Common/PeCoffLoaderEx.c +++ b/BaseTools/Source/C/Common/PeCoffLoaderEx.c @@ -15,7 +15,6 @@ SPDX-License-Identifier: BSD-2-Clause-Patent #include "CommonLib.h" #include "EfiUtilityMsgs.h" - #define EXT_IMM64(Value, Address, Size, InstPos, ValPos) \ Value |= (((UINT64)((*(Address) >> InstPos) & (((UINT64)1 << Size) - 1))) << ValPos) @@ -23,47 +22,47 @@ SPDX-License-Identifier: BSD-2-Clause-Patent *(UINT32*)Address = (*(UINT32*)Address & ~(((1 << Size) - 1) << InstPos)) | \ ((UINT32)((((UINT64)Value >> ValPos) & (((UINT64)1 << Size) - 1))) << InstPos) -#define IMM64_IMM7B_INST_WORD_X 3 -#define IMM64_IMM7B_SIZE_X 7 -#define IMM64_IMM7B_INST_WORD_POS_X 4 -#define IMM64_IMM7B_VAL_POS_X 0 - -#define IMM64_IMM9D_INST_WORD_X 3 -#define IMM64_IMM9D_SIZE_X 9 -#define IMM64_IMM9D_INST_WORD_POS_X 18 -#define IMM64_IMM9D_VAL_POS_X 7 - -#define IMM64_IMM5C_INST_WORD_X 3 -#define IMM64_IMM5C_SIZE_X 5 -#define IMM64_IMM5C_INST_WORD_POS_X 13 -#define IMM64_IMM5C_VAL_POS_X 16 - -#define IMM64_IC_INST_WORD_X 3 -#define IMM64_IC_SIZE_X 1 -#define IMM64_IC_INST_WORD_POS_X 12 -#define IMM64_IC_VAL_POS_X 21 - -#define IMM64_IMM41a_INST_WORD_X 1 -#define IMM64_IMM41a_SIZE_X 10 -#define IMM64_IMM41a_INST_WORD_POS_X 14 -#define IMM64_IMM41a_VAL_POS_X 22 - -#define IMM64_IMM41b_INST_WORD_X 1 -#define IMM64_IMM41b_SIZE_X 8 -#define IMM64_IMM41b_INST_WORD_POS_X 24 -#define IMM64_IMM41b_VAL_POS_X 32 - -#define IMM64_IMM41c_INST_WORD_X 2 -#define IMM64_IMM41c_SIZE_X 23 -#define IMM64_IMM41c_INST_WORD_POS_X 0 -#define IMM64_IMM41c_VAL_POS_X 40 - -#define IMM64_SIGN_INST_WORD_X 3 -#define IMM64_SIGN_SIZE_X 1 -#define IMM64_SIGN_INST_WORD_POS_X 27 -#define IMM64_SIGN_VAL_POS_X 63 - -UINT32 *RiscVHi20Fixup = NULL; +#define IMM64_IMM7B_INST_WORD_X 3 +#define IMM64_IMM7B_SIZE_X 7 +#define IMM64_IMM7B_INST_WORD_POS_X 4 +#define IMM64_IMM7B_VAL_POS_X 0 + +#define IMM64_IMM9D_INST_WORD_X 3 +#define IMM64_IMM9D_SIZE_X 9 +#define IMM64_IMM9D_INST_WORD_POS_X 18 +#define IMM64_IMM9D_VAL_POS_X 7 + +#define IMM64_IMM5C_INST_WORD_X 3 +#define IMM64_IMM5C_SIZE_X 5 +#define IMM64_IMM5C_INST_WORD_POS_X 13 +#define IMM64_IMM5C_VAL_POS_X 16 + +#define IMM64_IC_INST_WORD_X 3 +#define IMM64_IC_SIZE_X 1 +#define IMM64_IC_INST_WORD_POS_X 12 +#define IMM64_IC_VAL_POS_X 21 + +#define IMM64_IMM41a_INST_WORD_X 1 +#define IMM64_IMM41a_SIZE_X 10 +#define IMM64_IMM41a_INST_WORD_POS_X 14 +#define IMM64_IMM41a_VAL_POS_X 22 + +#define IMM64_IMM41b_INST_WORD_X 1 +#define IMM64_IMM41b_SIZE_X 8 +#define IMM64_IMM41b_INST_WORD_POS_X 24 +#define IMM64_IMM41b_VAL_POS_X 32 + +#define IMM64_IMM41c_INST_WORD_X 2 +#define IMM64_IMM41c_SIZE_X 23 +#define IMM64_IMM41c_INST_WORD_POS_X 0 +#define IMM64_IMM41c_VAL_POS_X 40 + +#define IMM64_SIGN_INST_WORD_X 3 +#define IMM64_SIGN_SIZE_X 1 +#define IMM64_SIGN_INST_WORD_POS_X 27 +#define IMM64_SIGN_VAL_POS_X 63 + +UINT32 *RiscVHi20Fixup = NULL; /** Performs an IA-32 specific relocation fixup @@ -77,10 +76,10 @@ UINT32 *RiscVHi20Fixup = NULL; **/ RETURN_STATUS PeCoffLoaderRelocateIa32Image ( - IN UINT16 *Reloc, - IN OUT CHAR8 *Fixup, - IN OUT CHAR8 **FixupData, - IN UINT64 Adjust + IN UINT16 *Reloc, + IN OUT CHAR8 *Fixup, + IN OUT CHAR8 **FixupData, + IN UINT64 Adjust ) { return RETURN_UNSUPPORTED; @@ -98,61 +97,65 @@ PeCoffLoaderRelocateIa32Image ( **/ RETURN_STATUS PeCoffLoaderRelocateRiscVImage ( - IN UINT16 *Reloc, - IN OUT CHAR8 *Fixup, - IN OUT CHAR8 **FixupData, - IN UINT64 Adjust + IN UINT16 *Reloc, + IN OUT CHAR8 *Fixup, + IN OUT CHAR8 **FixupData, + IN UINT64 Adjust ) { - UINT32 Value; - UINT32 Value2; + UINT32 Value; + UINT32 Value2; switch ((*Reloc) >> 12) { - case EFI_IMAGE_REL_BASED_RISCV_HI20: - RiscVHi20Fixup = (UINT32 *) Fixup; + case EFI_IMAGE_REL_BASED_RISCV_HI20: + RiscVHi20Fixup = (UINT32 *)Fixup; break; - case EFI_IMAGE_REL_BASED_RISCV_LOW12I: + case EFI_IMAGE_REL_BASED_RISCV_LOW12I: if (RiscVHi20Fixup != NULL) { - Value = (UINT32)(RV_X(*RiscVHi20Fixup, 12, 20) << 12); - Value2 = (UINT32)(RV_X(*(UINT32 *)Fixup, 20, 12)); + Value = (UINT32)(RV_X (*RiscVHi20Fixup, 12, 20) << 12); + Value2 = (UINT32)(RV_X (*(UINT32 *)Fixup, 20, 12)); if (Value2 & (RISCV_IMM_REACH/2)) { Value2 |= ~(RISCV_IMM_REACH-1); } - Value += Value2; - Value += (UINT32)Adjust; - Value2 = RISCV_CONST_HIGH_PART (Value); + + Value += Value2; + Value += (UINT32)Adjust; + Value2 = RISCV_CONST_HIGH_PART (Value); *(UINT32 *)RiscVHi20Fixup = (RV_X (Value2, 12, 20) << 12) | \ - (RV_X (*(UINT32 *)RiscVHi20Fixup, 0, 12)); + (RV_X (*(UINT32 *)RiscVHi20Fixup, 0, 12)); *(UINT32 *)Fixup = (RV_X (Value, 0, 12) << 20) | \ (RV_X (*(UINT32 *)Fixup, 0, 20)); } + RiscVHi20Fixup = NULL; break; - case EFI_IMAGE_REL_BASED_RISCV_LOW12S: + case EFI_IMAGE_REL_BASED_RISCV_LOW12S: if (RiscVHi20Fixup != NULL) { - Value = (UINT32)(RV_X(*RiscVHi20Fixup, 12, 20) << 12); - Value2 = (UINT32)(RV_X(*(UINT32 *)Fixup, 7, 5) | (RV_X(*(UINT32 *)Fixup, 25, 7) << 5)); + Value = (UINT32)(RV_X (*RiscVHi20Fixup, 12, 20) << 12); + Value2 = (UINT32)(RV_X (*(UINT32 *)Fixup, 7, 5) | (RV_X (*(UINT32 *)Fixup, 25, 7) << 5)); if (Value2 & (RISCV_IMM_REACH/2)) { Value2 |= ~(RISCV_IMM_REACH-1); } - Value += Value2; - Value += (UINT32)Adjust; - Value2 = RISCV_CONST_HIGH_PART (Value); + + Value += Value2; + Value += (UINT32)Adjust; + Value2 = RISCV_CONST_HIGH_PART (Value); *(UINT32 *)RiscVHi20Fixup = (RV_X (Value2, 12, 20) << 12) | \ - (RV_X (*(UINT32 *)RiscVHi20Fixup, 0, 12)); - Value2 = *(UINT32 *)Fixup & 0x01fff07f; - Value &= RISCV_IMM_REACH - 1; - *(UINT32 *)Fixup = Value2 | (UINT32)(((RV_X(Value, 0, 5) << 7) | (RV_X(Value, 5, 7) << 25))); + (RV_X (*(UINT32 *)RiscVHi20Fixup, 0, 12)); + Value2 = *(UINT32 *)Fixup & 0x01fff07f; + Value &= RISCV_IMM_REACH - 1; + *(UINT32 *)Fixup = Value2 | (UINT32)(((RV_X (Value, 0, 5) << 7) | (RV_X (Value, 5, 7) << 25))); } + RiscVHi20Fixup = NULL; break; - default: + default: return EFI_UNSUPPORTED; - } + return RETURN_SUCCESS; } @@ -167,7 +170,7 @@ PeCoffLoaderRelocateRiscVImage ( **/ UINT16 ThumbMovtImmediateAddress ( - IN UINT16 *Instruction + IN UINT16 *Instruction ) { UINT32 Movt; @@ -188,7 +191,6 @@ ThumbMovtImmediateAddress ( return Address; } - /** Update an ARM MOVT or MOVW immediate instruction immediate data. @@ -197,15 +199,15 @@ ThumbMovtImmediateAddress ( **/ VOID ThumbMovtImmediatePatch ( - IN OUT UINT16 *Instruction, - IN UINT16 Address + IN OUT UINT16 *Instruction, + IN UINT16 Address ) { UINT16 Patch; // First 16-bit chunk of instruction - Patch = ((Address >> 12) & 0x000f); // imm4 - Patch |= (((Address & BIT11) != 0) ? BIT10 : 0); // i + Patch = ((Address >> 12) & 0x000f); // imm4 + Patch |= (((Address & BIT11) != 0) ? BIT10 : 0); // i *Instruction = (*Instruction & ~0x040f) | Patch; // Second 16-bit chunk of instruction @@ -227,7 +229,7 @@ ThumbMovtImmediatePatch ( UINT32 EFIAPI ThumbMovwMovtImmediateAddress ( - IN UINT16 *Instructions + IN UINT16 *Instructions ) { UINT16 *Word; @@ -239,7 +241,6 @@ ThumbMovwMovtImmediateAddress ( return (ThumbMovtImmediateAddress (Top) << 16) + ThumbMovtImmediateAddress (Word); } - /** Update an ARM MOVW/MOVT immediate instruction instruction pair. @@ -249,8 +250,8 @@ ThumbMovwMovtImmediateAddress ( VOID EFIAPI ThumbMovwMovtImmediatePatch ( - IN OUT UINT16 *Instructions, - IN UINT32 Address + IN OUT UINT16 *Instructions, + IN UINT32 Address ) { UINT16 *Word; @@ -263,7 +264,6 @@ ThumbMovwMovtImmediatePatch ( ThumbMovtImmediatePatch (Top, (UINT16)(Address >> 16)); } - /** Performs an ARM-based specific relocation fixup and is a no-op on other instruction sets. @@ -278,35 +278,34 @@ ThumbMovwMovtImmediatePatch ( **/ RETURN_STATUS PeCoffLoaderRelocateArmImage ( - IN UINT16 **Reloc, - IN OUT CHAR8 *Fixup, - IN OUT CHAR8 **FixupData, - IN UINT64 Adjust + IN UINT16 **Reloc, + IN OUT CHAR8 *Fixup, + IN OUT CHAR8 **FixupData, + IN UINT64 Adjust ) { - UINT16 *Fixup16; - UINT32 FixupVal; + UINT16 *Fixup16; + UINT32 FixupVal; - Fixup16 = (UINT16 *) Fixup; + Fixup16 = (UINT16 *)Fixup; switch ((**Reloc) >> 12) { + case EFI_IMAGE_REL_BASED_ARM_MOV32T: + FixupVal = ThumbMovwMovtImmediateAddress (Fixup16) + (UINT32)Adjust; + ThumbMovwMovtImmediatePatch (Fixup16, FixupVal); - case EFI_IMAGE_REL_BASED_ARM_MOV32T: - FixupVal = ThumbMovwMovtImmediateAddress (Fixup16) + (UINT32)Adjust; - ThumbMovwMovtImmediatePatch (Fixup16, FixupVal); + if (*FixupData != NULL) { + *FixupData = ALIGN_POINTER (*FixupData, sizeof (UINT64)); + CopyMem (*FixupData, Fixup16, sizeof (UINT64)); + *FixupData = *FixupData + sizeof (UINT64); + } + break; - if (*FixupData != NULL) { - *FixupData = ALIGN_POINTER(*FixupData, sizeof(UINT64)); - CopyMem (*FixupData, Fixup16, sizeof (UINT64)); - *FixupData = *FixupData + sizeof(UINT64); - } - break; - - case EFI_IMAGE_REL_BASED_ARM_MOV32A: - // break omitted - ARM instruction encoding not implemented - default: - return RETURN_UNSUPPORTED; + case EFI_IMAGE_REL_BASED_ARM_MOV32A: + // break omitted - ARM instruction encoding not implemented + default: + return RETURN_UNSUPPORTED; } return RETURN_SUCCESS; @@ -330,10 +329,10 @@ PeCoffLoaderRelocateLoongArch64Image ( IN UINT64 Adjust ) { - UINT8 RelocType; - UINT64 Value; - UINT64 Tmp1; - UINT64 Tmp2; + UINT8 RelocType; + UINT64 Value; + UINT64 Tmp1; + UINT64 Tmp2; RelocType = ((*Reloc) >> 12); Value = 0; diff --git a/BaseTools/Source/C/Common/SimpleFileParsing.c b/BaseTools/Source/C/Common/SimpleFileParsing.c index 51d59cf4a765..cec82b540569 100644 --- a/BaseTools/Source/C/Common/SimpleFileParsing.c +++ b/BaseTools/Source/C/Common/SimpleFileParsing.c @@ -27,46 +27,46 @@ SPDX-License-Identifier: BSD-2-Clause-Patent // #define MAX_STRING_IDENTIFIER_NAME 100 -#define T_CHAR_SPACE ' ' -#define T_CHAR_NULL 0 -#define T_CHAR_CR '\r' -#define T_CHAR_TAB '\t' -#define T_CHAR_LF '\n' -#define T_CHAR_SLASH '/' -#define T_CHAR_BACKSLASH '\\' -#define T_CHAR_DOUBLE_QUOTE '"' -#define T_CHAR_LC_X 'x' -#define T_CHAR_0 '0' -#define T_CHAR_STAR '*' +#define T_CHAR_SPACE ' ' +#define T_CHAR_NULL 0 +#define T_CHAR_CR '\r' +#define T_CHAR_TAB '\t' +#define T_CHAR_LF '\n' +#define T_CHAR_SLASH '/' +#define T_CHAR_BACKSLASH '\\' +#define T_CHAR_DOUBLE_QUOTE '"' +#define T_CHAR_LC_X 'x' +#define T_CHAR_0 '0' +#define T_CHAR_STAR '*' // // We keep a linked list of these for the source files we process // typedef struct _SOURCE_FILE { - FILE *Fptr; - CHAR8 *FileBuffer; - CHAR8 *FileBufferPtr; - UINTN FileSize; - CHAR8 FileName[MAX_PATH]; - UINTN LineNum; - BOOLEAN EndOfFile; - BOOLEAN SkipToHash; - struct _SOURCE_FILE *Previous; - struct _SOURCE_FILE *Next; - CHAR8 ControlCharacter; + FILE *Fptr; + CHAR8 *FileBuffer; + CHAR8 *FileBufferPtr; + UINTN FileSize; + CHAR8 FileName[MAX_PATH]; + UINTN LineNum; + BOOLEAN EndOfFile; + BOOLEAN SkipToHash; + struct _SOURCE_FILE *Previous; + struct _SOURCE_FILE *Next; + CHAR8 ControlCharacter; } SOURCE_FILE; typedef struct { - CHAR8 *FileBufferPtr; + CHAR8 *FileBufferPtr; } FILE_POSITION; // // Keep all our module globals in this structure // STATIC struct { - SOURCE_FILE SourceFile; - BOOLEAN VerboseFile; - BOOLEAN VerboseToken; + SOURCE_FILE SourceFile; + BOOLEAN VerboseFile; + BOOLEAN VerboseToken; } mGlobals; STATIC @@ -81,7 +81,7 @@ UINTN t_strncmp ( CHAR8 *Str1, CHAR8 *Str2, - INTN Len + INTN Len ); STATIC @@ -93,31 +93,31 @@ t_strlen ( STATIC VOID RewindFile ( - SOURCE_FILE *SourceFile + SOURCE_FILE *SourceFile ); STATIC BOOLEAN IsWhiteSpace ( - SOURCE_FILE *SourceFile + SOURCE_FILE *SourceFile ); STATIC UINTN SkipWhiteSpace ( - SOURCE_FILE *SourceFile + SOURCE_FILE *SourceFile ); STATIC BOOLEAN EndOfFile ( - SOURCE_FILE *SourceFile + SOURCE_FILE *SourceFile ); STATIC VOID PreprocessFile ( - SOURCE_FILE *SourceFile + SOURCE_FILE *SourceFile ); STATIC @@ -130,26 +130,26 @@ t_strcpy ( STATIC STATUS ProcessIncludeFile ( - SOURCE_FILE *SourceFile, - SOURCE_FILE *ParentSourceFile + SOURCE_FILE *SourceFile, + SOURCE_FILE *ParentSourceFile ); STATIC STATUS ProcessFile ( - SOURCE_FILE *SourceFile + SOURCE_FILE *SourceFile ); STATIC STATUS GetFilePosition ( - FILE_POSITION *Fpos + FILE_POSITION *Fpos ); STATIC STATUS SetFilePosition ( - FILE_POSITION *Fpos + FILE_POSITION *Fpos ); /** @@ -160,7 +160,7 @@ SFPInit ( VOID ) { - memset ((VOID *) &mGlobals, 0, sizeof (mGlobals)); + memset ((VOID *)&mGlobals, 0, sizeof (mGlobals)); return STATUS_SUCCESS; } @@ -204,10 +204,11 @@ SFPGetFileName ( **/ STATUS SFPOpenFile ( - CHAR8 *FileName + CHAR8 *FileName ) { STATUS Status; + t_strcpy (mGlobals.SourceFile.FileName, FileName); Status = ProcessIncludeFile (&mGlobals.SourceFile, NULL); return Status; @@ -223,7 +224,7 @@ SFPOpenFile ( is not a subset of some other token. The file pointer is advanced past the token in the input file. - + @param Str the token to look for @retval TRUE the token is next @@ -235,6 +236,7 @@ SFPIsToken ( ) { UINTN Len; + SkipWhiteSpace (&mGlobals.SourceFile); if (EndOfFile (&mGlobals.SourceFile)) { return FALSE; @@ -259,7 +261,7 @@ SFPIsToken ( @note: A keyword is defined as a "special" string that has a non-alphanumeric character following it. - + @param Str keyword to look for @retval TRUE the keyword is next @@ -271,6 +273,7 @@ SFPIsKeyword ( ) { UINTN Len; + SkipWhiteSpace (&mGlobals.SourceFile); if (EndOfFile (&mGlobals.SourceFile)) { return FALSE; @@ -299,7 +302,7 @@ SFPIsKeyword ( Preceding white space is ignored. The parser's buffer pointer is advanced past the end of the token. - + @param Str pointer to a copy of the next token @param Len size of buffer pointed to by Str @@ -319,12 +322,14 @@ SFPGetNextToken ( if (EndOfFile (&mGlobals.SourceFile)) { return FALSE; } + // // Have to have enough string for at least one char and a null-terminator // if (Len < 2) { return FALSE; } + // // Look at the first character. If it's an identifier, then treat it // as such @@ -340,7 +345,8 @@ SFPGetNextToken ( ((TempChar >= 'A') && (TempChar <= 'Z')) || ((TempChar >= '0') && (TempChar <= '9')) || (TempChar == '_') - ) { + ) + { Str[Index] = mGlobals.SourceFile.FileBufferPtr[0]; mGlobals.SourceFile.FileBufferPtr++; Index++; @@ -351,6 +357,7 @@ SFPGetNextToken ( break; } } + // // Null terminate and return success // @@ -380,6 +387,7 @@ SFPGetNextToken ( Index++; } } + // // See if we just ran out of file contents, but did find a token // @@ -403,11 +411,12 @@ SFPGetNextToken ( **/ BOOLEAN SFPGetGuidToken ( - CHAR8 *Str, - UINT32 Len + CHAR8 *Str, + UINT32 Len ) { UINT32 Index; + SkipWhiteSpace (&mGlobals.SourceFile); if (EndOfFile (&mGlobals.SourceFile)) { return FALSE; @@ -438,7 +447,8 @@ SFPSkipToToken ( ) { UINTN Len; - CHAR8 *SavePos; + CHAR8 *SavePos; + Len = t_strlen (Str); SavePos = mGlobals.SourceFile.FileBufferPtr; SkipWhiteSpace (&mGlobals.SourceFile); @@ -467,10 +477,10 @@ SFPSkipToToken ( **/ BOOLEAN SFPGetNumber ( - UINTN *Value + UINTN *Value ) { - int Val; + int Val; SkipWhiteSpace (&mGlobals.SourceFile); if (EndOfFile (&mGlobals.SourceFile)) { @@ -488,7 +498,7 @@ SFPGetNumber ( mGlobals.SourceFile.FileBufferPtr += 2; sscanf (mGlobals.SourceFile.FileBufferPtr, "%x", &Val); - *Value = (UINT32) Val; + *Value = (UINT32)Val; while (isxdigit ((int)mGlobals.SourceFile.FileBufferPtr[0])) { mGlobals.SourceFile.FileBufferPtr++; } @@ -538,13 +548,13 @@ SFPCloseFile ( STATIC STATUS ProcessIncludeFile ( - SOURCE_FILE *SourceFile, - SOURCE_FILE *ParentSourceFile + SOURCE_FILE *SourceFile, + SOURCE_FILE *ParentSourceFile ) { - STATIC UINTN NestDepth = 0; - CHAR8 FoundFileName[MAX_PATH]; - STATUS Status; + STATIC UINTN NestDepth = 0; + CHAR8 FoundFileName[MAX_PATH]; + STATUS Status; Status = STATUS_SUCCESS; NestDepth++; @@ -561,10 +571,11 @@ ProcessIncludeFile ( // Make sure we didn't exceed our maximum nesting depth // if (NestDepth > MAX_NEST_DEPTH) { - Error (NULL, 0, 3001, "Not Supported", "%s exceeds max nesting depth (%u)", SourceFile->FileName, (unsigned) NestDepth); + Error (NULL, 0, 3001, "Not Supported", "%s exceeds max nesting depth (%u)", SourceFile->FileName, (unsigned)NestDepth); Status = STATUS_ERROR; goto Finish; } + // // Try to open the file locally, and if that fails try along our include paths. // @@ -572,6 +583,7 @@ ProcessIncludeFile ( if ((SourceFile->Fptr = fopen (LongFilePath (FoundFileName), "rb")) == NULL) { return STATUS_ERROR; } + // // Process the file found // @@ -599,7 +611,7 @@ ProcessIncludeFile ( STATIC STATUS ProcessFile ( - SOURCE_FILE *SourceFile + SOURCE_FILE *SourceFile ) { // @@ -609,18 +621,18 @@ ProcessFile ( fseek (SourceFile->Fptr, 0, SEEK_END); SourceFile->FileSize = ftell (SourceFile->Fptr); if (mGlobals.VerboseFile) { - printf ("FileSize = %u (0x%X)\n", (unsigned) SourceFile->FileSize, (unsigned) SourceFile->FileSize); + printf ("FileSize = %u (0x%X)\n", (unsigned)SourceFile->FileSize, (unsigned)SourceFile->FileSize); } fseek (SourceFile->Fptr, 0, SEEK_SET); - SourceFile->FileBuffer = (CHAR8 *) malloc (SourceFile->FileSize + sizeof (CHAR8 )); + SourceFile->FileBuffer = (CHAR8 *)malloc (SourceFile->FileSize + sizeof (CHAR8)); if (SourceFile->FileBuffer == NULL) { Error (NULL, 0, 4001, "Resource: memory cannot be allocated", NULL); return STATUS_ERROR; } - fread ((VOID *) SourceFile->FileBuffer, SourceFile->FileSize, 1, SourceFile->Fptr); - SourceFile->FileBuffer[(SourceFile->FileSize / sizeof (CHAR8 ))] = T_CHAR_NULL; + fread ((VOID *)SourceFile->FileBuffer, SourceFile->FileSize, 1, SourceFile->Fptr); + SourceFile->FileBuffer[(SourceFile->FileSize / sizeof (CHAR8))] = T_CHAR_NULL; // // Pre-process the file to replace comments with spaces // @@ -638,12 +650,12 @@ ProcessFile ( STATIC VOID PreprocessFile ( - SOURCE_FILE *SourceFile + SOURCE_FILE *SourceFile ) { - BOOLEAN InComment; - BOOLEAN SlashSlashComment; - int LineNum; + BOOLEAN InComment; + BOOLEAN SlashSlashComment; + int LineNum; RewindFile (SourceFile); InComment = FALSE; @@ -669,10 +681,11 @@ PreprocessFile ( // Check for */ comment end // } else if (InComment && - !SlashSlashComment && - (SourceFile->FileBufferPtr[0] == T_CHAR_STAR) && - (SourceFile->FileBufferPtr[1] == T_CHAR_SLASH) - ) { + !SlashSlashComment && + (SourceFile->FileBufferPtr[0] == T_CHAR_STAR) && + (SourceFile->FileBufferPtr[1] == T_CHAR_SLASH) + ) + { SourceFile->FileBufferPtr[0] = T_CHAR_SPACE; SourceFile->FileBufferPtr++; SourceFile->FileBufferPtr[0] = T_CHAR_SPACE; @@ -701,6 +714,7 @@ PreprocessFile ( SourceFile->FileBufferPtr++; } } + // // Could check for end-of-file and still in a comment, but // should not be necessary. So just restore the file pointers. @@ -740,8 +754,8 @@ PreprocessFile ( **/ BOOLEAN SFPGetQuotedString ( - CHAR8 *Str, - INTN Length + CHAR8 *Str, + INTN Length ) { SkipWhiteSpace (&mGlobals.SourceFile); @@ -755,6 +769,7 @@ SFPGetQuotedString ( if (EndOfFile (&mGlobals.SourceFile)) { return FALSE; } + // // Check for closing quote // @@ -770,6 +785,7 @@ SFPGetQuotedString ( mGlobals.SourceFile.FileBufferPtr++; } } + // // First character was not a quote, or the input string length was // insufficient to contain the quoted string, so return failure code. @@ -797,15 +813,15 @@ SFPIsEOF ( STATIC CHAR8 * GetQuotedString ( - SOURCE_FILE *SourceFile, - BOOLEAN Optional + SOURCE_FILE *SourceFile, + BOOLEAN Optional ) { - CHAR8 *String; - CHAR8 *Start; - CHAR8 *Ptr; - UINTN Len; - BOOLEAN PreviousBackslash; + CHAR8 *String; + CHAR8 *Start; + CHAR8 *Ptr; + UINTN Len; + BOOLEAN PreviousBackslash; if (SourceFile->FileBufferPtr[0] != T_CHAR_DOUBLE_QUOTE) { if (Optional == FALSE) { @@ -840,14 +856,16 @@ GetQuotedString ( } else { SourceFile->FileBufferPtr++; } + // // Now allocate memory for the string and save it off // - String = (CHAR8 *) malloc ((Len + 1) * sizeof (CHAR8 )); + String = (CHAR8 *)malloc ((Len + 1) * sizeof (CHAR8)); if (String == NULL) { Error (NULL, 0, 4001, "Resource: memory cannot be allocated", NULL); return NULL; } + // // Copy the string from the file buffer to the local copy. // We do no reformatting of it whatsoever at this point. @@ -863,18 +881,19 @@ GetQuotedString ( *Ptr = 0; return String; } + #endif STATIC BOOLEAN EndOfFile ( - SOURCE_FILE *SourceFile + SOURCE_FILE *SourceFile ) { // // The file buffer pointer will typically get updated before the End-of-file flag in the // source file structure, so check it first. // - if (SourceFile->FileBufferPtr >= SourceFile->FileBuffer + SourceFile->FileSize / sizeof (CHAR8 )) { + if (SourceFile->FileBufferPtr >= SourceFile->FileBuffer + SourceFile->FileSize / sizeof (CHAR8)) { SourceFile->EndOfFile = TRUE; return TRUE; } @@ -890,19 +909,20 @@ EndOfFile ( STATIC VOID ProcessTokenInclude ( - SOURCE_FILE *SourceFile + SOURCE_FILE *SourceFile ) { - CHAR8 IncludeFileName[MAX_PATH]; - CHAR8 *To; - UINTN Len; - BOOLEAN ReportedError; - SOURCE_FILE IncludedSourceFile; + CHAR8 IncludeFileName[MAX_PATH]; + CHAR8 *To; + UINTN Len; + BOOLEAN ReportedError; + SOURCE_FILE IncludedSourceFile; ReportedError = FALSE; if (SkipWhiteSpace (SourceFile) == 0) { Warning (SourceFile->FileName, SourceFile->LineNum, 0, "expected whitespace following #include keyword", NULL); } + // // Should be quoted file name // @@ -927,6 +947,7 @@ ProcessTokenInclude ( SourceFile->FileBufferPtr++; break; } + // // If too long, then report the error once and process until the closing quote // @@ -937,7 +958,7 @@ ProcessTokenInclude ( } if (!ReportedError) { - *To = (CHAR8 ) SourceFile->FileBufferPtr[0]; + *To = (CHAR8)SourceFile->FileBufferPtr[0]; To++; } @@ -946,65 +967,67 @@ ProcessTokenInclude ( if (!ReportedError) { *To = 0; - memset ((CHAR8 *) &IncludedSourceFile, 0, sizeof (SOURCE_FILE)); + memset ((CHAR8 *)&IncludedSourceFile, 0, sizeof (SOURCE_FILE)); strcpy (IncludedSourceFile.FileName, IncludeFileName); ProcessIncludeFile (&IncludedSourceFile, SourceFile); } - return ; + return; FailDone: // // Error recovery -- skip to next # // SourceFile->SkipToHash = TRUE; } + #endif STATIC BOOLEAN IsWhiteSpace ( - SOURCE_FILE *SourceFile + SOURCE_FILE *SourceFile ) { switch (*SourceFile->FileBufferPtr) { - case T_CHAR_NULL: - case T_CHAR_CR: - case T_CHAR_SPACE: - case T_CHAR_TAB: - case T_CHAR_LF: - return TRUE; - - default: - return FALSE; - } -} - -UINTN -SkipWhiteSpace ( - SOURCE_FILE *SourceFile - ) -{ - UINTN Count; - - Count = 0; - while (!EndOfFile (SourceFile)) { - Count++; - switch (*SourceFile->FileBufferPtr) { case T_CHAR_NULL: case T_CHAR_CR: case T_CHAR_SPACE: case T_CHAR_TAB: - SourceFile->FileBufferPtr++; - break; - case T_CHAR_LF: - SourceFile->FileBufferPtr++; - SourceFile->LineNum++; - break; + return TRUE; default: - return Count - 1; + return FALSE; + } +} + +UINTN +SkipWhiteSpace ( + SOURCE_FILE *SourceFile + ) +{ + UINTN Count; + + Count = 0; + while (!EndOfFile (SourceFile)) { + Count++; + switch (*SourceFile->FileBufferPtr) { + case T_CHAR_NULL: + case T_CHAR_CR: + case T_CHAR_SPACE: + case T_CHAR_TAB: + SourceFile->FileBufferPtr++; + break; + + case T_CHAR_LF: + SourceFile->FileBufferPtr++; + SourceFile->LineNum++; + break; + + default: + return Count - 1; } } + // // Some tokens require trailing whitespace. If we're at the end of the // file, then we count that as well. @@ -1056,6 +1079,7 @@ t_strlen ( ) { UINTN Len; + Len = 0; while (*Str) { Len++; @@ -1070,7 +1094,7 @@ UINTN t_strncmp ( CHAR8 *Str1, CHAR8 *Str2, - INTN Len + INTN Len ) { while (Len > 0) { @@ -1093,7 +1117,8 @@ t_strcpy ( CHAR8 *Src ) { - CHAR8 *SaveDest; + CHAR8 *SaveDest; + SaveDest = Dest; while (*Src) { *Dest = *Src; @@ -1108,7 +1133,7 @@ t_strcpy ( STATIC VOID RewindFile ( - SOURCE_FILE *SourceFile + SOURCE_FILE *SourceFile ) { SourceFile->LineNum = 1; @@ -1119,11 +1144,12 @@ RewindFile ( STATIC UINT32 GetHexChars ( - CHAR8 *Buffer, - UINT32 BufferLen + CHAR8 *Buffer, + UINT32 BufferLen ) { UINT32 Len; + Len = 0; while (!EndOfFile (&mGlobals.SourceFile) && (Len < BufferLen)) { if (isxdigit ((int)mGlobals.SourceFile.FileBufferPtr[0])) { @@ -1134,6 +1160,7 @@ GetHexChars ( break; } } + // // Null terminate if we can // @@ -1158,19 +1185,19 @@ GetHexChars ( **/ BOOLEAN SFPGetGuid ( - INTN GuidStyle, - EFI_GUID *Value + INTN GuidStyle, + EFI_GUID *Value ) { - INT32 Value32; - UINT32 Index; - FILE_POSITION FPos; - CHAR8 TempString[20]; - CHAR8 TempString2[3]; - CHAR8 *From; - CHAR8 *To; - UINT32 Len; - BOOLEAN Status; + INT32 Value32; + UINT32 Index; + FILE_POSITION FPos; + CHAR8 TempString[20]; + CHAR8 TempString2[3]; + CHAR8 *From; + CHAR8 *To; + UINT32 Len; + BOOLEAN Status; Status = FALSE; // @@ -1207,7 +1234,7 @@ SFPGetGuid ( } sscanf (TempString, "%x", &Value32); - Value->Data2 = (UINT16) Value32; + Value->Data2 = (UINT16)Value32; if (mGlobals.SourceFile.FileBufferPtr[0] != '-') { goto Done; @@ -1220,7 +1247,7 @@ SFPGetGuid ( } sscanf (TempString, "%x", &Value32); - Value->Data3 = (UINT16) Value32; + Value->Data3 = (UINT16)Value32; // // Parse the "AAAA" as two bytes // @@ -1235,8 +1262,8 @@ SFPGetGuid ( } sscanf (TempString, "%x", &Value32); - Value->Data4[0] = (UINT8) (Value32 >> 8); - Value->Data4[1] = (UINT8) Value32; + Value->Data4[0] = (UINT8)(Value32 >> 8); + Value->Data4[1] = (UINT8)Value32; if (mGlobals.SourceFile.FileBufferPtr[0] != '-') { goto Done; } @@ -1250,13 +1277,14 @@ SFPGetGuid ( if ((Len == 0) || (Len > 12)) { goto Done; } + // // Insert leading 0's to make life easier // if (Len != 12) { - From = TempString + Len - 1; - To = TempString + 11; - TempString[12] = 0; + From = TempString + Len - 1; + To = TempString + 11; + TempString[12] = 0; while (From >= TempString) { *To = *From; To--; @@ -1268,6 +1296,7 @@ SFPGetGuid ( To--; } } + // // Now parse each byte // @@ -1277,10 +1306,10 @@ SFPGetGuid ( // Copy the two characters from the input string to something // we can parse. // - TempString2[0] = TempString[Index * 2]; - TempString2[1] = TempString[Index * 2 + 1]; + TempString2[0] = TempString[Index * 2]; + TempString2[1] = TempString[Index * 2 + 1]; sscanf (TempString2, "%x", &Value32); - Value->Data4[Index + 2] = (UINT8) Value32; + Value->Data4[Index + 2] = (UINT8)Value32; } Status = TRUE; @@ -1302,7 +1331,7 @@ SFPGetGuid ( STATIC STATUS GetFilePosition ( - FILE_POSITION *Fpos + FILE_POSITION *Fpos ) { Fpos->FileBufferPtr = mGlobals.SourceFile.FileBufferPtr; @@ -1312,7 +1341,7 @@ GetFilePosition ( STATIC STATUS SetFilePosition ( - FILE_POSITION *Fpos + FILE_POSITION *Fpos ) { // diff --git a/BaseTools/Source/C/Common/StringFuncs.c b/BaseTools/Source/C/Common/StringFuncs.c index bc85ba012440..b39b907a9571 100644 --- a/BaseTools/Source/C/Common/StringFuncs.c +++ b/BaseTools/Source/C/Common/StringFuncs.c @@ -21,12 +21,12 @@ SPDX-License-Identifier: BSD-2-Clause-Patent @return CHAR8* - NULL if there are not enough resources **/ -CHAR8* +CHAR8 * CloneString ( - IN CHAR8 *String + IN CHAR8 *String ) { - CHAR8* NewString; + CHAR8 *NewString; NewString = malloc (strlen (String) + 1); if (NewString != NULL) { @@ -45,10 +45,10 @@ CloneString ( **/ EFI_STATUS StripInfDscStringInPlace ( - IN CHAR8 *String + IN CHAR8 *String ) { - CHAR8 *Pos; + CHAR8 *Pos; if (String == NULL) { return EFI_INVALID_PARAMETER; @@ -59,6 +59,7 @@ StripInfDscStringInPlace ( // for (Pos = String; isspace ((int)*Pos); Pos++) { } + if (Pos != String) { memmove (String, Pos, strlen (Pos) + 1); } @@ -70,12 +71,12 @@ StripInfDscStringInPlace ( // What about multiline comments? // - Pos = (CHAR8 *) strstr (String, "//"); + Pos = (CHAR8 *)strstr (String, "//"); if (Pos != NULL) { *Pos = '\0'; } - Pos = (CHAR8 *) strchr (String, '#'); + Pos = (CHAR8 *)strchr (String, '#'); if (Pos != NULL) { *Pos = '\0'; } @@ -86,8 +87,10 @@ StripInfDscStringInPlace ( for (Pos = String + strlen (String); ((Pos - 1) >= String) && (isspace ((int)*(Pos - 1))); Pos-- - ) { + ) + { } + *Pos = '\0'; return EFI_SUCCESS; @@ -101,21 +104,22 @@ StripInfDscStringInPlace ( @return EFI_STATUS **/ -STRING_LIST* +STRING_LIST * SplitStringByWhitespace ( - IN CHAR8 *String + IN CHAR8 *String ) { - CHAR8 *Pos; - CHAR8 *EndOfSubString; - CHAR8 *EndOfString; - STRING_LIST *Output; - UINTN Item; + CHAR8 *Pos; + CHAR8 *EndOfSubString; + CHAR8 *EndOfString; + STRING_LIST *Output; + UINTN Item; String = CloneString (String); if (String == NULL) { return NULL; } + EndOfString = String + strlen (String); Output = NewStringList (); @@ -125,10 +129,11 @@ SplitStringByWhitespace ( Pos++; } - for (EndOfSubString=Pos; + for (EndOfSubString = Pos; (*EndOfSubString != '\0') && !isspace ((int)*EndOfSubString); EndOfSubString++ - ) { + ) + { } if (EndOfSubString == Pos) { @@ -151,15 +156,17 @@ SplitStringByWhitespace ( @return STRING_LIST* - Null if there is not enough resources to create the object. **/ -STRING_LIST* +STRING_LIST * NewStringList ( ) { - STRING_LIST *NewList; + STRING_LIST *NewList; + NewList = AllocateStringListStruct (0); if (NewList != NULL) { NewList->Count = 0; } + return NewList; } @@ -171,13 +178,13 @@ NewStringList ( **/ EFI_STATUS AppendCopyOfStringToList ( - IN OUT STRING_LIST **StringList, - IN CHAR8 *String + IN OUT STRING_LIST **StringList, + IN CHAR8 *String ) { - STRING_LIST *OldList; - STRING_LIST *NewList; - CHAR8 *NewString; + STRING_LIST *OldList; + STRING_LIST *NewList; + CHAR8 *NewString; OldList = *StringList; NewList = AllocateStringListStruct (OldList->Count + 1); @@ -196,7 +203,7 @@ AppendCopyOfStringToList ( OldList->Strings, sizeof (OldList->Strings[0]) * OldList->Count ); - NewList->Count = OldList->Count + 1; + NewList->Count = OldList->Count + 1; NewList->Strings[OldList->Count] = NewString; *StringList = NewList; @@ -215,7 +222,7 @@ AppendCopyOfStringToList ( **/ EFI_STATUS RemoveLastStringFromList ( - IN STRING_LIST *StringList + IN STRING_LIST *StringList ) { if (StringList->Count == 0) { @@ -234,12 +241,12 @@ RemoveLastStringFromList ( @return EFI_STATUS **/ -STRING_LIST* +STRING_LIST * AllocateStringListStruct ( - IN UINTN StringCount + IN UINTN StringCount ) { - return malloc (OFFSET_OF(STRING_LIST, Strings[StringCount + 1])); + return malloc (OFFSET_OF (STRING_LIST, Strings[StringCount + 1])); } /** @@ -249,7 +256,7 @@ AllocateStringListStruct ( **/ VOID FreeStringList ( - IN STRING_LIST *StringList + IN STRING_LIST *StringList ) { while (StringList->Count > 0) { @@ -267,20 +274,21 @@ FreeStringList ( @return CHAR8* - The string list represented with a single string. The returned string must be freed by the caller. **/ -CHAR8* +CHAR8 * StringListToString ( - IN STRING_LIST *StringList + IN STRING_LIST *StringList ) { - UINTN Count; - UINTN Length; - CHAR8 *NewString; + UINTN Count; + UINTN Length; + CHAR8 *NewString; Length = 2; for (Count = 0; Count < StringList->Count; Count++) { if (Count > 0) { Length += 2; } + Length += strlen (StringList->Strings[Count]) + 2; } @@ -288,6 +296,7 @@ StringListToString ( if (NewString == NULL) { return NewString; } + NewString[0] = '\0'; strcat (NewString, "["); @@ -295,10 +304,12 @@ StringListToString ( if (Count > 0) { strcat (NewString, ", "); } + strcat (NewString, "\""); strcat (NewString, StringList->Strings[Count]); strcat (NewString, "\""); } + strcat (NewString, "]"); return NewString; @@ -308,20 +319,19 @@ StringListToString ( Prints out the string list @param StringList The string list to print - + @return EFI_STATUS **/ VOID PrintStringList ( - IN STRING_LIST *StringList + IN STRING_LIST *StringList ) { - CHAR8* String; + CHAR8 *String; + String = StringListToString (StringList); if (String != NULL) { printf ("%s", String); free (String); } } - - diff --git a/BaseTools/Source/C/Common/TianoCompress.c b/BaseTools/Source/C/Common/TianoCompress.c index 2f484b9731dc..5df6947258d7 100644 --- a/BaseTools/Source/C/Common/TianoCompress.c +++ b/BaseTools/Source/C/Common/TianoCompress.c @@ -28,9 +28,9 @@ typedef INT32 NODE; #define CODE_BIT 16 #define NIL 0 #define MAX_HASH_VAL (3 * WNDSIZ + (WNDSIZ / 512 + 1) * UINT8_MAX) -#define HASH(p, c) ((p) + ((c) << (WNDBIT - 9)) + WNDSIZ * 2) -#define CRCPOLY 0xA001 -#define UPDATE_CRC(c) mCrc = mCrcTable[(mCrc ^ (c)) & 0xFF] ^ (mCrc >> UINT8_BIT) +#define HASH(p, c) ((p) + ((c) << (WNDBIT - 9)) + WNDSIZ * 2) +#define CRCPOLY 0xA001 +#define UPDATE_CRC(c) mCrc = mCrcTable[(mCrc ^ (c)) & 0xFF] ^ (mCrc >> UINT8_BIT) // // C: the Char&Len Set; P: the Position Set; T: the exTra Set @@ -42,9 +42,9 @@ typedef INT32 NODE; #define NT (CODE_BIT + 3) #define TBIT 5 #if NT > NP -#define NPT NT +#define NPT NT #else -#define NPT NP +#define NPT NP #endif // // Function Prototypes @@ -52,8 +52,8 @@ typedef INT32 NODE; STATIC VOID -PutDword( - IN UINT32 Data +PutDword ( + IN UINT32 Data ); STATIC @@ -84,15 +84,15 @@ Child ( STATIC VOID MakeChild ( - IN NODE NodeQ, - IN UINT8 CharC, - IN NODE NodeR + IN NODE NodeQ, + IN UINT8 CharC, + IN NODE NodeR ); STATIC VOID Split ( - IN NODE Old + IN NODE Old ); STATIC @@ -128,9 +128,9 @@ CountTFreq ( STATIC VOID WritePTLen ( - IN INT32 Number, - IN INT32 nbit, - IN INT32 Special + IN INT32 Number, + IN INT32 nbit, + IN INT32 Special ); STATIC @@ -142,13 +142,13 @@ WriteCLen ( STATIC VOID EncodeC ( - IN INT32 Value + IN INT32 Value ); STATIC VOID EncodeP ( - IN UINT32 Value + IN UINT32 Value ); STATIC @@ -160,8 +160,8 @@ SendBlock ( STATIC VOID Output ( - IN UINT32 c, - IN UINT32 p + IN UINT32 c, + IN UINT32 p ); STATIC @@ -185,15 +185,15 @@ MakeCrcTable ( STATIC VOID PutBits ( - IN INT32 Number, - IN UINT32 Value + IN INT32 Number, + IN UINT32 Value ); STATIC INT32 FreadCrc ( - OUT UINT8 *Pointer, - IN INT32 Number + OUT UINT8 *Pointer, + IN INT32 Number ); STATIC @@ -205,35 +205,35 @@ InitPutBits ( STATIC VOID CountLen ( - IN INT32 Index + IN INT32 Index ); STATIC VOID MakeLen ( - IN INT32 Root + IN INT32 Root ); STATIC VOID DownHeap ( - IN INT32 Index + IN INT32 Index ); STATIC VOID MakeCode ( - IN INT32 Number, - IN UINT8 Len[ ], - OUT UINT16 Code[] + IN INT32 Number, + IN UINT8 Len[], + OUT UINT16 Code[] ); STATIC INT32 MakeTree ( - IN INT32 NParm, + IN INT32 NParm, IN UINT16 FreqParm[], - OUT UINT8 LenParm[ ], + OUT UINT8 LenParm[], OUT UINT16 CodeParm[] ); @@ -242,16 +242,16 @@ MakeTree ( // STATIC UINT8 *mSrc, *mDst, *mSrcUpperLimit, *mDstUpperLimit; -STATIC UINT8 *mLevel, *mText, *mChildCount, *mBuf, mCLen[NC], mPTLen[NPT], *mLen; -STATIC INT16 mHeap[NC + 1]; -STATIC INT32 mRemainder, mMatchLen, mBitCount, mHeapSize, mN; -STATIC UINT32 mBufSiz = 0, mOutputPos, mOutputMask, mSubBitBuf, mCrc; -STATIC UINT32 mCompSize, mOrigSize; +STATIC UINT8 *mLevel, *mText, *mChildCount, *mBuf, mCLen[NC], mPTLen[NPT], *mLen; +STATIC INT16 mHeap[NC + 1]; +STATIC INT32 mRemainder, mMatchLen, mBitCount, mHeapSize, mN; +STATIC UINT32 mBufSiz = 0, mOutputPos, mOutputMask, mSubBitBuf, mCrc; +STATIC UINT32 mCompSize, mOrigSize; -STATIC UINT16 *mFreq, *mSortPtr, mLenCnt[17], mLeft[2 * NC - 1], mRight[2 * NC - 1], mCrcTable[UINT8_MAX + 1], - mCFreq[2 * NC - 1], mCCode[NC], mPFreq[2 * NP - 1], mPTCode[NPT], mTFreq[2 * NT - 1]; +STATIC UINT16 *mFreq, *mSortPtr, mLenCnt[17], mLeft[2 * NC - 1], mRight[2 * NC - 1], mCrcTable[UINT8_MAX + 1], + mCFreq[2 * NC - 1], mCCode[NC], mPFreq[2 * NP - 1], mPTCode[NPT], mTFreq[2 * NT - 1]; -STATIC NODE mPos, mMatchPos, mAvail, *mPosition, *mParent, *mPrev, *mNext = NULL; +STATIC NODE mPos, mMatchPos, mAvail, *mPosition, *mParent, *mPrev, *mNext = NULL; // // functions @@ -288,28 +288,28 @@ TianoCompress ( // // Initializations // - mBufSiz = 0; - mBuf = NULL; - mText = NULL; - mLevel = NULL; - mChildCount = NULL; - mPosition = NULL; - mParent = NULL; - mPrev = NULL; - mNext = NULL; + mBufSiz = 0; + mBuf = NULL; + mText = NULL; + mLevel = NULL; + mChildCount = NULL; + mPosition = NULL; + mParent = NULL; + mPrev = NULL; + mNext = NULL; - mSrc = SrcBuffer; - mSrcUpperLimit = mSrc + SrcSize; - mDst = DstBuffer; - mDstUpperLimit = mDst +*DstSize; + mSrc = SrcBuffer; + mSrcUpperLimit = mSrc + SrcSize; + mDst = DstBuffer; + mDstUpperLimit = mDst +*DstSize; PutDword (0L); PutDword (0L); MakeCrcTable (); - mOrigSize = mCompSize = 0; - mCrc = INIT_CRC; + mOrigSize = mCompSize = 0; + mCrc = INIT_CRC; // // Compress it @@ -318,12 +318,14 @@ TianoCompress ( if (EFI_ERROR (Status)) { return EFI_OUT_OF_RESOURCES; } + // // Null terminate the compressed data // if (mDst < mDstUpperLimit) { *mDst++ = 0; } + // // Fill in compressed size and original size // @@ -341,7 +343,6 @@ TianoCompress ( *DstSize = mCompSize + 1 + 8; return EFI_SUCCESS; } - } /** @@ -352,23 +353,23 @@ TianoCompress ( STATIC VOID PutDword ( - IN UINT32 Data + IN UINT32 Data ) { if (mDst < mDstUpperLimit) { - *mDst++ = (UINT8) (((UINT8) (Data)) & 0xff); + *mDst++ = (UINT8)(((UINT8)(Data)) & 0xff); } if (mDst < mDstUpperLimit) { - *mDst++ = (UINT8) (((UINT8) (Data >> 0x08)) & 0xff); + *mDst++ = (UINT8)(((UINT8)(Data >> 0x08)) & 0xff); } if (mDst < mDstUpperLimit) { - *mDst++ = (UINT8) (((UINT8) (Data >> 0x10)) & 0xff); + *mDst++ = (UINT8)(((UINT8)(Data >> 0x10)) & 0xff); } if (mDst < mDstUpperLimit) { - *mDst++ = (UINT8) (((UINT8) (Data >> 0x18)) & 0xff); + *mDst++ = (UINT8)(((UINT8)(Data >> 0x18)) & 0xff); } } @@ -390,6 +391,7 @@ AllocateMemory ( if (mText == NULL) { return EFI_OUT_OF_RESOURCES; } + for (Index = 0; Index < WNDSIZ * 2 + MAXMATCH; Index++) { mText[Index] = 0; } @@ -400,13 +402,14 @@ AllocateMemory ( mParent = malloc (WNDSIZ * 2 * sizeof (*mParent)); mPrev = malloc (WNDSIZ * 2 * sizeof (*mPrev)); mNext = malloc ((MAX_HASH_VAL + 1) * sizeof (*mNext)); - if (mLevel == NULL || mChildCount == NULL || mPosition == NULL || - mParent == NULL || mPrev == NULL || mNext == NULL) { + if ((mLevel == NULL) || (mChildCount == NULL) || (mPosition == NULL) || + (mParent == NULL) || (mPrev == NULL) || (mNext == NULL)) + { return EFI_OUT_OF_RESOURCES; } - mBufSiz = BLKSIZ; - mBuf = malloc (mBufSiz); + mBufSiz = BLKSIZ; + mBuf = malloc (mBufSiz); while (mBuf == NULL) { mBufSiz = (mBufSiz / 10U) * 9U; if (mBufSiz < 4 * 1024U) { @@ -461,7 +464,7 @@ FreeMemory ( free (mBuf); } - return ; + return; } /** @@ -476,8 +479,8 @@ InitSlide ( NODE Index; for (Index = WNDSIZ; Index <= WNDSIZ + UINT8_MAX; Index++) { - mLevel[Index] = 1; - mPosition[Index] = NIL; /* sentinel */ + mLevel[Index] = 1; + mPosition[Index] = NIL; /* sentinel */ } for (Index = WNDSIZ; Index < WNDSIZ * 2; Index++) { @@ -486,7 +489,7 @@ InitSlide ( mAvail = 1; for (Index = 1; Index < WNDSIZ - 1; Index++) { - mNext[Index] = (NODE) (Index + 1); + mNext[Index] = (NODE)(Index + 1); } mNext[WNDSIZ - 1] = NIL; @@ -506,8 +509,8 @@ InitSlide ( STATIC NODE Child ( - IN NODE NodeQ, - IN UINT8 CharC + IN NODE NodeQ, + IN UINT8 CharC ) { NODE NodeR; @@ -534,21 +537,21 @@ Child ( STATIC VOID MakeChild ( - IN NODE Parent, - IN UINT8 CharC, - IN NODE Child + IN NODE Parent, + IN UINT8 CharC, + IN NODE Child ) { NODE Node1; NODE Node2; - Node1 = (NODE) HASH (Parent, CharC); - Node2 = mNext[Node1]; - mNext[Node1] = Child; - mNext[Child] = Node2; - mPrev[Node2] = Child; - mPrev[Child] = Node1; - mParent[Child] = Parent; + Node1 = (NODE)HASH (Parent, CharC); + Node2 = mNext[Node1]; + mNext[Node1] = Child; + mNext[Child] = Node2; + mPrev[Node2] = Child; + mPrev[Child] = Node1; + mParent[Child] = Parent; mChildCount[Parent]++; } @@ -560,24 +563,24 @@ MakeChild ( STATIC VOID Split ( - NODE Old + NODE Old ) { NODE New; NODE TempNode; - New = mAvail; - mAvail = mNext[New]; - mChildCount[New] = 0; - TempNode = mPrev[Old]; - mPrev[New] = TempNode; - mNext[TempNode] = New; - TempNode = mNext[Old]; - mNext[New] = TempNode; - mPrev[TempNode] = New; - mParent[New] = mParent[Old]; - mLevel[New] = (UINT8) mMatchLen; - mPosition[New] = mPos; + New = mAvail; + mAvail = mNext[New]; + mChildCount[New] = 0; + TempNode = mPrev[Old]; + mPrev[New] = TempNode; + mNext[TempNode] = New; + TempNode = mNext[Old]; + mNext[New] = TempNode; + mPrev[TempNode] = New; + mParent[New] = mParent[Old]; + mLevel[New] = (UINT8)mMatchLen; + mPosition[New] = mPos; MakeChild (New, mText[mMatchPos + mMatchLen], Old); MakeChild (New, mText[mPos + mMatchLen], mPos); } @@ -591,13 +594,13 @@ InsertNode ( VOID ) { - NODE NodeQ; - NODE NodeR; - NODE Index2; - NODE NodeT; - UINT8 CharC; - UINT8 *t1; - UINT8 *t2; + NODE NodeQ; + NODE NodeR; + NODE Index2; + NODE NodeT; + UINT8 CharC; + UINT8 *t1; + UINT8 *t2; if (mMatchLen >= 4) { // @@ -608,7 +611,7 @@ InsertNode ( // in DeleteNode() later. // mMatchLen--; - NodeR = (NODE) ((mMatchPos + 1) | WNDSIZ); + NodeR = (NODE)((mMatchPos + 1) | WNDSIZ); NodeQ = mParent[NodeR]; while (NodeQ == NIL) { NodeR = mNext[NodeR]; @@ -622,52 +625,53 @@ InsertNode ( NodeT = NodeQ; while (mPosition[NodeT] < 0) { - mPosition[NodeT] = mPos; - NodeT = mParent[NodeT]; + mPosition[NodeT] = mPos; + NodeT = mParent[NodeT]; } if (NodeT < WNDSIZ) { - mPosition[NodeT] = (NODE) (mPos | (UINT32) PERC_FLAG); + mPosition[NodeT] = (NODE)(mPos | (UINT32)PERC_FLAG); } } else { // // Locate the target tree // - NodeQ = (NODE) (mText[mPos] + WNDSIZ); + NodeQ = (NODE)(mText[mPos] + WNDSIZ); CharC = mText[mPos + 1]; NodeR = Child (NodeQ, CharC); if (NodeR == NIL) { MakeChild (NodeQ, CharC, mPos); mMatchLen = 1; - return ; + return; } mMatchLen = 2; } + // // Traverse down the tree to find a match. // Update Position value along the route. // Node split or creation is involved. // - for (;;) { + for ( ; ;) { if (NodeR >= WNDSIZ) { Index2 = MAXMATCH; mMatchPos = NodeR; } else { Index2 = mLevel[NodeR]; - mMatchPos = (NODE) (mPosition[NodeR] & (UINT32)~PERC_FLAG); + mMatchPos = (NODE)(mPosition[NodeR] & (UINT32) ~PERC_FLAG); } if (mMatchPos >= mPos) { mMatchPos -= WNDSIZ; } - t1 = &mText[mPos + mMatchLen]; - t2 = &mText[mMatchPos + mMatchLen]; + t1 = &mText[mPos + mMatchLen]; + t2 = &mText[mMatchPos + mMatchLen]; while (mMatchLen < Index2) { if (*t1 != *t2) { Split (NodeR); - return ; + return; } mMatchLen++; @@ -679,31 +683,30 @@ InsertNode ( break; } - mPosition[NodeR] = mPos; - NodeQ = NodeR; - NodeR = Child (NodeQ, *t1); + mPosition[NodeR] = mPos; + NodeQ = NodeR; + NodeR = Child (NodeQ, *t1); if (NodeR == NIL) { MakeChild (NodeQ, *t1, mPos); - return ; + return; } mMatchLen++; } - NodeT = mPrev[NodeR]; - mPrev[mPos] = NodeT; - mNext[NodeT] = mPos; - NodeT = mNext[NodeR]; - mNext[mPos] = NodeT; - mPrev[NodeT] = mPos; - mParent[mPos] = NodeQ; - mParent[NodeR] = NIL; + NodeT = mPrev[NodeR]; + mPrev[mPos] = NodeT; + mNext[NodeT] = mPos; + NodeT = mNext[NodeR]; + mNext[mPos] = NodeT; + mPrev[NodeT] = mPos; + mParent[mPos] = NodeQ; + mParent[NodeR] = NIL; // // Special usage of 'next' // mNext[NodeR] = mPos; - } /** @@ -723,7 +726,7 @@ DeleteNode ( NODE NodeU; if (mParent[mPos] == NIL) { - return ; + return; } NodeR = mPrev[mPos]; @@ -733,15 +736,15 @@ DeleteNode ( NodeR = mParent[mPos]; mParent[mPos] = NIL; if (NodeR >= WNDSIZ) { - return ; + return; } mChildCount[NodeR]--; if (mChildCount[NodeR] > 1) { - return ; + return; } - NodeT = (NODE) (mPosition[NodeR] & (UINT32)~PERC_FLAG); + NodeT = (NODE)(mPosition[NodeR] & (UINT32) ~PERC_FLAG); if (NodeT >= mPos) { NodeT -= WNDSIZ; } @@ -749,8 +752,8 @@ DeleteNode ( NodeS = NodeT; NodeQ = mParent[NodeR]; NodeU = mPosition[NodeQ]; - while (NodeU & (UINT32) PERC_FLAG) { - NodeU &= (UINT32)~PERC_FLAG; + while (NodeU & (UINT32)PERC_FLAG) { + NodeU &= (UINT32) ~PERC_FLAG; if (NodeU >= mPos) { NodeU -= WNDSIZ; } @@ -759,9 +762,9 @@ DeleteNode ( NodeS = NodeU; } - mPosition[NodeQ] = (NODE) (NodeS | WNDSIZ); - NodeQ = mParent[NodeQ]; - NodeU = mPosition[NodeQ]; + mPosition[NodeQ] = (NODE)(NodeS | WNDSIZ); + NodeQ = mParent[NodeQ]; + NodeU = mPosition[NodeQ]; } if (NodeQ < WNDSIZ) { @@ -773,24 +776,24 @@ DeleteNode ( NodeS = NodeU; } - mPosition[NodeQ] = (NODE) (NodeS | WNDSIZ | (UINT32) PERC_FLAG); + mPosition[NodeQ] = (NODE)(NodeS | WNDSIZ | (UINT32)PERC_FLAG); } - NodeS = Child (NodeR, mText[NodeT + mLevel[NodeR]]); - NodeT = mPrev[NodeS]; - NodeU = mNext[NodeS]; - mNext[NodeT] = NodeU; - mPrev[NodeU] = NodeT; - NodeT = mPrev[NodeR]; - mNext[NodeT] = NodeS; - mPrev[NodeS] = NodeT; - NodeT = mNext[NodeR]; - mPrev[NodeT] = NodeS; - mNext[NodeS] = NodeT; - mParent[NodeS] = mParent[NodeR]; - mParent[NodeR] = NIL; - mNext[NodeR] = mAvail; - mAvail = NodeR; + NodeS = Child (NodeR, mText[NodeT + mLevel[NodeR]]); + NodeT = mPrev[NodeS]; + NodeU = mNext[NodeS]; + mNext[NodeT] = NodeU; + mPrev[NodeU] = NodeT; + NodeT = mPrev[NodeR]; + mNext[NodeT] = NodeS; + mPrev[NodeS] = NodeT; + NodeT = mNext[NodeR]; + mPrev[NodeT] = NodeS; + mNext[NodeS] = NodeT; + mParent[NodeS] = mParent[NodeR]; + mParent[NodeR] = NIL; + mNext[NodeR] = mAvail; + mAvail = NodeR; } /** @@ -803,15 +806,15 @@ GetNextMatch ( VOID ) { - INT32 Number; + INT32 Number; mRemainder--; mPos++; if (mPos == WNDSIZ * 2) { memmove (&mText[0], &mText[WNDSIZ], WNDSIZ + MAXMATCH); - Number = FreadCrc (&mText[WNDSIZ + MAXMATCH], WNDSIZ); + Number = FreadCrc (&mText[WNDSIZ + MAXMATCH], WNDSIZ); mRemainder += Number; - mPos = WNDSIZ; + mPos = WNDSIZ; } DeleteNode (); @@ -844,38 +847,37 @@ Encode ( HufEncodeStart (); - mRemainder = FreadCrc (&mText[WNDSIZ], WNDSIZ + MAXMATCH); + mRemainder = FreadCrc (&mText[WNDSIZ], WNDSIZ + MAXMATCH); - mMatchLen = 0; - mPos = WNDSIZ; + mMatchLen = 0; + mPos = WNDSIZ; InsertNode (); if (mMatchLen > mRemainder) { mMatchLen = mRemainder; } while (mRemainder > 0) { - LastMatchLen = mMatchLen; - LastMatchPos = mMatchPos; + LastMatchLen = mMatchLen; + LastMatchPos = mMatchPos; GetNextMatch (); if (mMatchLen > mRemainder) { mMatchLen = mRemainder; } - if (mMatchLen > LastMatchLen || LastMatchLen < THRESHOLD) { + if ((mMatchLen > LastMatchLen) || (LastMatchLen < THRESHOLD)) { // // Not enough benefits are gained by outputting a pointer, // so just output the original character // Output (mText[mPos - 1], 0); - } else { - if (LastMatchLen == THRESHOLD) { if (((mPos - LastMatchPos - 2) & (WNDSIZ - 1)) > (1U << 11)) { Output (mText[mPos - 1], 0); continue; } } + // // Outputting a pointer is beneficial enough, do it. // @@ -909,10 +911,10 @@ CountTFreq ( VOID ) { - INT32 Index; - INT32 Index3; - INT32 Number; - INT32 Count; + INT32 Index; + INT32 Index3; + INT32 Number; + INT32 Count; for (Index = 0; Index < NT; Index++) { mTFreq[Index] = 0; @@ -934,7 +936,7 @@ CountTFreq ( } if (Count <= 2) { - mTFreq[0] = (UINT16) (mTFreq[0] + Count); + mTFreq[0] = (UINT16)(mTFreq[0] + Count); } else if (Count <= 18) { mTFreq[1]++; } else if (Count == 19) { @@ -959,13 +961,13 @@ CountTFreq ( STATIC VOID WritePTLen ( - IN INT32 Number, - IN INT32 nbit, - IN INT32 Special + IN INT32 Number, + IN INT32 nbit, + IN INT32 Special ) { - INT32 Index; - INT32 Index3; + INT32 Index; + INT32 Index3; while (Number > 0 && mPTLen[Number - 1] == 0) { Number--; @@ -1000,10 +1002,10 @@ WriteCLen ( VOID ) { - INT32 Index; - INT32 Index3; - INT32 Number; - INT32 Count; + INT32 Index; + INT32 Index3; + INT32 Number; + INT32 Count; Number = NC; while (Number > 0 && mCLen[Number - 1] == 0) { @@ -1045,7 +1047,7 @@ WriteCLen ( STATIC VOID EncodeC ( - IN INT32 Value + IN INT32 Value ) { PutBits (mCLen[Value], mCCode[Value]); @@ -1054,7 +1056,7 @@ EncodeC ( STATIC VOID EncodeP ( - IN UINT32 Value + IN UINT32 Value ) { UINT32 Index; @@ -1089,10 +1091,11 @@ SendBlock ( UINT32 Root; UINT32 Pos; UINT32 Size; + Flags = 0; - Root = MakeTree (NC, mCFreq, mCLen, mCCode); - Size = mCFreq[Root]; + Root = MakeTree (NC, mCFreq, mCLen, mCCode); + Size = mCFreq[Root]; PutBits (16, Size); if (Root >= NC) { CountTFreq (); @@ -1133,7 +1136,7 @@ SendBlock ( Index3 = mBuf[Pos++]; for (Index2 = 0; Index2 < 3; Index2++) { Index3 <<= UINT8_BIT; - Index3 += mBuf[Pos++]; + Index3 += mBuf[Pos++]; } EncodeP (Index3); @@ -1160,11 +1163,11 @@ SendBlock ( STATIC VOID Output ( - IN UINT32 CharC, - IN UINT32 Pos + IN UINT32 CharC, + IN UINT32 Pos ) { - STATIC UINT32 CPos; + STATIC UINT32 CPos; if ((mOutputMask >>= 1) == 0) { mOutputMask = 1U << (UINT8_BIT - 1); @@ -1178,19 +1181,19 @@ Output ( mOutputPos = 0; } - CPos = mOutputPos++; - mBuf[CPos] = 0; + CPos = mOutputPos++; + mBuf[CPos] = 0; } - mBuf[mOutputPos++] = (UINT8) CharC; + mBuf[mOutputPos++] = (UINT8)CharC; mCFreq[CharC]++; if (CharC >= (1U << UINT8_BIT)) { - mBuf[CPos] |= mOutputMask; - mBuf[mOutputPos++] = (UINT8) (Pos >> 24); - mBuf[mOutputPos++] = (UINT8) (Pos >> 16); - mBuf[mOutputPos++] = (UINT8) (Pos >> (UINT8_BIT)); - mBuf[mOutputPos++] = (UINT8) Pos; - CharC = 0; + mBuf[CPos] |= mOutputMask; + mBuf[mOutputPos++] = (UINT8)(Pos >> 24); + mBuf[mOutputPos++] = (UINT8)(Pos >> 16); + mBuf[mOutputPos++] = (UINT8)(Pos >> (UINT8_BIT)); + mBuf[mOutputPos++] = (UINT8)Pos; + CharC = 0; while (Pos) { Pos >>= 1; CharC++; @@ -1206,7 +1209,7 @@ HufEncodeStart ( VOID ) { - INT32 Index; + INT32 Index; for (Index = 0; Index < NC; Index++) { mCFreq[Index] = 0; @@ -1218,7 +1221,7 @@ HufEncodeStart ( mOutputPos = mOutputMask = 0; InitPutBits (); - return ; + return; } STATIC @@ -1234,7 +1237,7 @@ HufEncodeEnd ( // PutBits (UINT8_BIT - 1, 0); - return ; + return; } STATIC @@ -1257,37 +1260,37 @@ MakeCrcTable ( } } - mCrcTable[Index] = (UINT16) Temp; + mCrcTable[Index] = (UINT16)Temp; } } /** Outputs rightmost n bits of x - + @param Number the rightmost n bits of the data is used @param x the data **/ STATIC VOID PutBits ( - IN INT32 Number, - IN UINT32 Value + IN INT32 Number, + IN UINT32 Value ) { - UINT8 Temp; + UINT8 Temp; while (Number >= mBitCount) { // // Number -= mBitCount should never equal to 32 // - Temp = (UINT8) (mSubBitBuf | (Value >> (Number -= mBitCount))); + Temp = (UINT8)(mSubBitBuf | (Value >> (Number -= mBitCount))); if (mDst < mDstUpperLimit) { *mDst++ = Temp; } mCompSize++; - mSubBitBuf = 0; - mBitCount = UINT8_BIT; + mSubBitBuf = 0; + mBitCount = UINT8_BIT; } mSubBitBuf |= Value << (mBitCount -= Number); @@ -1304,11 +1307,11 @@ PutBits ( STATIC INT32 FreadCrc ( - OUT UINT8 *Pointer, - IN INT32 Number + OUT UINT8 *Pointer, + IN INT32 Number ) { - INT32 Index; + INT32 Index; for (Index = 0; mSrc < mSrcUpperLimit && Index < Number; Index++) { *Pointer++ = *mSrc++; @@ -1316,7 +1319,7 @@ FreadCrc ( Number = Index; - Pointer -= Number; + Pointer -= Number; mOrigSize += Number; Index--; while (Index >= 0) { @@ -1333,8 +1336,8 @@ InitPutBits ( VOID ) { - mBitCount = UINT8_BIT; - mSubBitBuf = 0; + mBitCount = UINT8_BIT; + mSubBitBuf = 0; } /** @@ -1345,7 +1348,7 @@ InitPutBits ( STATIC VOID CountLen ( - IN INT32 Index + IN INT32 Index ) { STATIC INT32 Depth = 0; @@ -1368,7 +1371,7 @@ CountLen ( STATIC VOID MakeLen ( - IN INT32 Root + IN INT32 Root ) { INT32 Index; @@ -1407,7 +1410,7 @@ MakeLen ( Index3 = mLenCnt[Index]; Index3--; while (Index3 >= 0) { - mLen[*mSortPtr++] = (UINT8) Index; + mLen[*mSortPtr++] = (UINT8)Index; Index3--; } } @@ -1416,19 +1419,19 @@ MakeLen ( STATIC VOID DownHeap ( - IN INT32 Index + IN INT32 Index ) { - INT32 Index2; - INT32 Index3; + INT32 Index2; + INT32 Index3; // // priority queue: send Index-th entry down heap // - Index3 = mHeap[Index]; - Index2 = 2 * Index; + Index3 = mHeap[Index]; + Index2 = 2 * Index; while (Index2 <= mHeapSize) { - if (Index2 < mHeapSize && mFreq[mHeap[Index2]] > mFreq[mHeap[Index2 + 1]]) { + if ((Index2 < mHeapSize) && (mFreq[mHeap[Index2]] > mFreq[mHeap[Index2 + 1]])) { Index2++; } @@ -1436,12 +1439,12 @@ DownHeap ( break; } - mHeap[Index] = mHeap[Index2]; - Index = Index2; - Index2 = 2 * Index; + mHeap[Index] = mHeap[Index2]; + Index = Index2; + Index2 = 2 * Index; } - mHeap[Index] = (INT16) Index3; + mHeap[Index] = (INT16)Index3; } /** @@ -1454,9 +1457,9 @@ DownHeap ( STATIC VOID MakeCode ( - IN INT32 Number, - IN UINT8 Len[ ], - OUT UINT16 Code[] + IN INT32 Number, + IN UINT8 Len[], + OUT UINT16 Code[] ) { INT32 Index; @@ -1464,7 +1467,7 @@ MakeCode ( Start[1] = 0; for (Index = 1; Index <= 16; Index++) { - Start[Index + 1] = (UINT16) ((Start[Index] + mLenCnt[Index]) << 1); + Start[Index + 1] = (UINT16)((Start[Index] + mLenCnt[Index]) << 1); } for (Index = 0; Index < Number; Index++) { @@ -1485,16 +1488,16 @@ MakeCode ( STATIC INT32 MakeTree ( - IN INT32 NParm, + IN INT32 NParm, IN UINT16 FreqParm[], - OUT UINT8 LenParm[ ], + OUT UINT8 LenParm[], OUT UINT16 CodeParm[] ) { - INT32 Index; - INT32 Index2; - INT32 Index3; - INT32 Avail; + INT32 Index; + INT32 Index2; + INT32 Index3; + INT32 Avail; // // make tree, calculate len[], return root @@ -1509,7 +1512,7 @@ MakeTree ( mLen[Index] = 0; if (mFreq[Index]) { mHeapSize++; - mHeap[mHeapSize] = (INT16) Index; + mHeap[mHeapSize] = (INT16)Index; } } @@ -1529,22 +1532,22 @@ MakeTree ( do { Index = mHeap[1]; if (Index < mN) { - *mSortPtr++ = (UINT16) Index; + *mSortPtr++ = (UINT16)Index; } mHeap[1] = mHeap[mHeapSize--]; DownHeap (1); Index2 = mHeap[1]; if (Index2 < mN) { - *mSortPtr++ = (UINT16) Index2; + *mSortPtr++ = (UINT16)Index2; } Index3 = Avail++; - mFreq[Index3] = (UINT16) (mFreq[Index] + mFreq[Index2]); - mHeap[1] = (INT16) Index3; + mFreq[Index3] = (UINT16)(mFreq[Index] + mFreq[Index2]); + mHeap[1] = (INT16)Index3; DownHeap (1); - mLeft[Index3] = (UINT16) Index; - mRight[Index3] = (UINT16) Index2; + mLeft[Index3] = (UINT16)Index; + mRight[Index3] = (UINT16)Index2; } while (mHeapSize > 1); mSortPtr = CodeParm; -- 2.37.1 (Apple Git-137.1)