More renames for Tool Packages
git-svn-id: https://edk2.svn.sourceforge.net/svnroot/edk2/trunk/edk2@1675 6f19259b-4bc3-4df7-8a09-765794883524
This commit is contained in:
lhauch
508
Tools/CodeTools/Source/Common/CommonLib.c
Normal file
508
Tools/CodeTools/Source/Common/CommonLib.c
Normal file
@ -0,0 +1,508 @@
|
||||
/*++
|
||||
|
||||
Copyright (c) 2004, Intel Corporation
|
||||
All rights reserved. This program and the accompanying materials
|
||||
are licensed and made available under the terms and conditions of the BSD License
|
||||
which accompanies this distribution. The full text of the license may be found at
|
||||
http://opensource.org/licenses/bsd-license.php
|
||||
|
||||
THE PROGRAM IS DISTRIBUTED UNDER THE BSD LICENSE ON AN "AS IS" BASIS,
|
||||
WITHOUT WARRANTIES OR REPRESENTATIONS OF ANY KIND, EITHER EXPRESS OR IMPLIED.
|
||||
|
||||
Module Name:
|
||||
|
||||
CommonLib.c
|
||||
|
||||
Abstract:
|
||||
|
||||
Common Library Functions
|
||||
|
||||
--*/
|
||||
|
||||
#include <stdio.h>
|
||||
#include <string.h>
|
||||
#include <stdlib.h>
|
||||
#include "CommonLib.h"
|
||||
|
||||
VOID
|
||||
PeiZeroMem (
|
||||
IN VOID *Buffer,
|
||||
IN UINTN Size
|
||||
)
|
||||
/*++
|
||||
|
||||
Routine Description:
|
||||
|
||||
Set Buffer to zero for Size bytes.
|
||||
|
||||
Arguments:
|
||||
|
||||
Buffer - Memory to set.
|
||||
|
||||
Size - Number of bytes to set
|
||||
|
||||
Returns:
|
||||
|
||||
None
|
||||
|
||||
--*/
|
||||
{
|
||||
INT8 *Ptr;
|
||||
|
||||
Ptr = Buffer;
|
||||
while (Size--) {
|
||||
*(Ptr++) = 0;
|
||||
}
|
||||
}
|
||||
|
||||
VOID
|
||||
PeiCopyMem (
|
||||
IN VOID *Destination,
|
||||
IN VOID *Source,
|
||||
IN UINTN Length
|
||||
)
|
||||
/*++
|
||||
|
||||
Routine Description:
|
||||
|
||||
Copy Length bytes from Source to Destination.
|
||||
|
||||
Arguments:
|
||||
|
||||
Destination - Target of copy
|
||||
|
||||
Source - Place to copy from
|
||||
|
||||
Length - Number of bytes to copy
|
||||
|
||||
Returns:
|
||||
|
||||
None
|
||||
|
||||
--*/
|
||||
{
|
||||
CHAR8 *Destination8;
|
||||
CHAR8 *Source8;
|
||||
|
||||
Destination8 = Destination;
|
||||
Source8 = Source;
|
||||
while (Length--) {
|
||||
*(Destination8++) = *(Source8++);
|
||||
}
|
||||
}
|
||||
|
||||
VOID
|
||||
ZeroMem (
|
||||
IN VOID *Buffer,
|
||||
IN UINTN Size
|
||||
)
|
||||
{
|
||||
PeiZeroMem (Buffer, Size);
|
||||
}
|
||||
|
||||
VOID
|
||||
CopyMem (
|
||||
IN VOID *Destination,
|
||||
IN VOID *Source,
|
||||
IN UINTN Length
|
||||
)
|
||||
{
|
||||
PeiCopyMem (Destination, Source, Length);
|
||||
}
|
||||
|
||||
INTN
|
||||
CompareGuid (
|
||||
IN EFI_GUID *Guid1,
|
||||
IN EFI_GUID *Guid2
|
||||
)
|
||||
/*++
|
||||
|
||||
Routine Description:
|
||||
|
||||
Compares to GUIDs
|
||||
|
||||
Arguments:
|
||||
|
||||
Guid1 - guid to compare
|
||||
Guid2 - guid to compare
|
||||
|
||||
Returns:
|
||||
= 0 if Guid1 == Guid2
|
||||
!= 0 if Guid1 != Guid2
|
||||
|
||||
--*/
|
||||
{
|
||||
INT32 *g1;
|
||||
INT32 *g2;
|
||||
INT32 r;
|
||||
|
||||
//
|
||||
// Compare 32 bits at a time
|
||||
//
|
||||
g1 = (INT32 *) Guid1;
|
||||
g2 = (INT32 *) Guid2;
|
||||
|
||||
r = g1[0] - g2[0];
|
||||
r |= g1[1] - g2[1];
|
||||
r |= g1[2] - g2[2];
|
||||
r |= g1[3] - g2[3];
|
||||
|
||||
return r;
|
||||
}
|
||||
|
||||
EFI_STATUS
|
||||
GetFileImage (
|
||||
IN CHAR8 *InputFileName,
|
||||
OUT CHAR8 **InputFileImage,
|
||||
OUT UINT32 *BytesRead
|
||||
)
|
||||
/*++
|
||||
|
||||
Routine Description:
|
||||
|
||||
This function opens a file and reads it into a memory buffer. The function
|
||||
will allocate the memory buffer and returns the size of the buffer.
|
||||
|
||||
Arguments:
|
||||
|
||||
InputFileName The name of the file to read.
|
||||
InputFileImage A pointer to the memory buffer.
|
||||
BytesRead The size of the memory buffer.
|
||||
|
||||
Returns:
|
||||
|
||||
EFI_SUCCESS The function completed successfully.
|
||||
EFI_INVALID_PARAMETER One of the input parameters was invalid.
|
||||
EFI_ABORTED An error occurred.
|
||||
EFI_OUT_OF_RESOURCES No resource to complete operations.
|
||||
|
||||
--*/
|
||||
{
|
||||
FILE *InputFile;
|
||||
UINT32 FileSize;
|
||||
|
||||
//
|
||||
// Verify input parameters.
|
||||
//
|
||||
if (InputFileName == NULL || strlen (InputFileName) == 0 || InputFileImage == NULL) {
|
||||
return EFI_INVALID_PARAMETER;
|
||||
}
|
||||
//
|
||||
// Open the file and copy contents into a memory buffer.
|
||||
//
|
||||
//
|
||||
// Open the file
|
||||
//
|
||||
InputFile = fopen (InputFileName, "rb");
|
||||
if (InputFile == NULL) {
|
||||
printf ("ERROR: Could not open input file \"%s\".\n", InputFileName);
|
||||
return EFI_ABORTED;
|
||||
}
|
||||
//
|
||||
// Go to the end so that we can determine the file size
|
||||
//
|
||||
if (fseek (InputFile, 0, SEEK_END)) {
|
||||
printf ("ERROR: System error reading input file \"%s\".\n", InputFileName);
|
||||
fclose (InputFile);
|
||||
return EFI_ABORTED;
|
||||
}
|
||||
//
|
||||
// Get the file size
|
||||
//
|
||||
FileSize = ftell (InputFile);
|
||||
if (FileSize == -1) {
|
||||
printf ("ERROR: System error parsing input file \"%s\".\n", InputFileName);
|
||||
fclose (InputFile);
|
||||
return EFI_ABORTED;
|
||||
}
|
||||
//
|
||||
// Allocate a buffer
|
||||
//
|
||||
*InputFileImage = malloc (FileSize);
|
||||
if (*InputFileImage == NULL) {
|
||||
fclose (InputFile);
|
||||
return EFI_OUT_OF_RESOURCES;
|
||||
}
|
||||
//
|
||||
// Reset to the beginning of the file
|
||||
//
|
||||
if (fseek (InputFile, 0, SEEK_SET)) {
|
||||
printf ("ERROR: System error reading input file \"%s\".\n", InputFileName);
|
||||
fclose (InputFile);
|
||||
free (*InputFileImage);
|
||||
*InputFileImage = NULL;
|
||||
return EFI_ABORTED;
|
||||
}
|
||||
//
|
||||
// Read all of the file contents.
|
||||
//
|
||||
*BytesRead = fread (*InputFileImage, sizeof (UINT8), FileSize, InputFile);
|
||||
if (*BytesRead != sizeof (UINT8) * FileSize) {
|
||||
printf ("ERROR: Reading file \"%s\"%i.\n", InputFileName);
|
||||
fclose (InputFile);
|
||||
free (*InputFileImage);
|
||||
*InputFileImage = NULL;
|
||||
return EFI_ABORTED;
|
||||
}
|
||||
//
|
||||
// Close the file
|
||||
//
|
||||
fclose (InputFile);
|
||||
|
||||
return EFI_SUCCESS;
|
||||
}
|
||||
|
||||
UINT8
|
||||
CalculateChecksum8 (
|
||||
IN UINT8 *Buffer,
|
||||
IN UINTN Size
|
||||
)
|
||||
/*++
|
||||
|
||||
Routine Description:
|
||||
|
||||
This function calculates the value needed for a valid UINT8 checksum
|
||||
|
||||
Arguments:
|
||||
|
||||
Buffer Pointer to buffer containing byte data of component.
|
||||
Size Size of the buffer
|
||||
|
||||
Returns:
|
||||
|
||||
The 8 bit checksum value needed.
|
||||
|
||||
--*/
|
||||
{
|
||||
return (UINT8) (0x100 - CalculateSum8 (Buffer, Size));
|
||||
}
|
||||
|
||||
UINT8
|
||||
CalculateSum8 (
|
||||
IN UINT8 *Buffer,
|
||||
IN UINTN Size
|
||||
)
|
||||
/*++
|
||||
|
||||
Routine Description::
|
||||
|
||||
This function calculates the UINT8 sum for the requested region.
|
||||
|
||||
Arguments:
|
||||
|
||||
Buffer Pointer to buffer containing byte data of component.
|
||||
Size Size of the buffer
|
||||
|
||||
Returns:
|
||||
|
||||
The 8 bit checksum value needed.
|
||||
|
||||
--*/
|
||||
{
|
||||
UINTN Index;
|
||||
UINT8 Sum;
|
||||
|
||||
Sum = 0;
|
||||
|
||||
//
|
||||
// Perform the byte sum for buffer
|
||||
//
|
||||
for (Index = 0; Index < Size; Index++) {
|
||||
Sum = (UINT8) (Sum + Buffer[Index]);
|
||||
}
|
||||
|
||||
return Sum;
|
||||
}
|
||||
|
||||
UINT16
|
||||
CalculateChecksum16 (
|
||||
IN UINT16 *Buffer,
|
||||
IN UINTN Size
|
||||
)
|
||||
/*++
|
||||
|
||||
Routine Description::
|
||||
|
||||
This function calculates the value needed for a valid UINT16 checksum
|
||||
|
||||
Arguments:
|
||||
|
||||
Buffer Pointer to buffer containing byte data of component.
|
||||
Size Size of the buffer
|
||||
|
||||
Returns:
|
||||
|
||||
The 16 bit checksum value needed.
|
||||
|
||||
--*/
|
||||
{
|
||||
return (UINT16) (0x10000 - CalculateSum16 (Buffer, Size));
|
||||
}
|
||||
|
||||
UINT16
|
||||
CalculateSum16 (
|
||||
IN UINT16 *Buffer,
|
||||
IN UINTN Size
|
||||
)
|
||||
/*++
|
||||
|
||||
Routine Description:
|
||||
|
||||
This function calculates the UINT16 sum for the requested region.
|
||||
|
||||
Arguments:
|
||||
|
||||
Buffer Pointer to buffer containing byte data of component.
|
||||
Size Size of the buffer
|
||||
|
||||
Returns:
|
||||
|
||||
The 16 bit checksum
|
||||
|
||||
--*/
|
||||
{
|
||||
UINTN Index;
|
||||
UINT16 Sum;
|
||||
|
||||
Sum = 0;
|
||||
|
||||
//
|
||||
// Perform the word sum for buffer
|
||||
//
|
||||
for (Index = 0; Index < Size; Index++) {
|
||||
Sum = (UINT16) (Sum + Buffer[Index]);
|
||||
}
|
||||
|
||||
return (UINT16) Sum;
|
||||
}
|
||||
|
||||
EFI_STATUS
|
||||
PrintGuid (
|
||||
IN EFI_GUID *Guid
|
||||
)
|
||||
/*++
|
||||
|
||||
Routine Description:
|
||||
|
||||
This function prints a GUID to STDOUT.
|
||||
|
||||
Arguments:
|
||||
|
||||
Guid Pointer to a GUID to print.
|
||||
|
||||
Returns:
|
||||
|
||||
EFI_SUCCESS The GUID was printed.
|
||||
EFI_INVALID_PARAMETER The input was NULL.
|
||||
|
||||
--*/
|
||||
{
|
||||
if (Guid == NULL) {
|
||||
printf ("ERROR: PrintGuid called with a NULL value.\n");
|
||||
return EFI_INVALID_PARAMETER;
|
||||
}
|
||||
|
||||
printf (
|
||||
"%08x-%04x-%04x-%02x%02x-%02x%02x%02x%02x%02x%02x\n",
|
||||
Guid->Data1,
|
||||
Guid->Data2,
|
||||
Guid->Data3,
|
||||
Guid->Data4[0],
|
||||
Guid->Data4[1],
|
||||
Guid->Data4[2],
|
||||
Guid->Data4[3],
|
||||
Guid->Data4[4],
|
||||
Guid->Data4[5],
|
||||
Guid->Data4[6],
|
||||
Guid->Data4[7]
|
||||
);
|
||||
return EFI_SUCCESS;
|
||||
}
|
||||
|
||||
EFI_STATUS
|
||||
PrintGuidToBuffer (
|
||||
IN EFI_GUID *Guid,
|
||||
IN OUT UINT8 *Buffer,
|
||||
IN UINT32 BufferLen,
|
||||
IN BOOLEAN Uppercase
|
||||
)
|
||||
/*++
|
||||
|
||||
Routine Description:
|
||||
|
||||
This function prints a GUID to a buffer
|
||||
|
||||
Arguments:
|
||||
|
||||
Guid - Pointer to a GUID to print.
|
||||
Buffer - Pointer to a user-provided buffer to print to
|
||||
BufferLen - Size of the Buffer
|
||||
Uppercase - If use upper case.
|
||||
|
||||
Returns:
|
||||
|
||||
EFI_SUCCESS The GUID was printed.
|
||||
EFI_INVALID_PARAMETER The input was NULL.
|
||||
EFI_BUFFER_TOO_SMALL The input buffer was not big enough
|
||||
|
||||
--*/
|
||||
{
|
||||
if (Guid == NULL) {
|
||||
printf ("ERROR: PrintGuidToBuffer() called with a NULL value\n");
|
||||
return EFI_INVALID_PARAMETER;
|
||||
}
|
||||
|
||||
if (BufferLen < PRINTED_GUID_BUFFER_SIZE) {
|
||||
printf ("ERORR: PrintGuidToBuffer() called with invalid buffer size\n");
|
||||
return EFI_BUFFER_TOO_SMALL;
|
||||
}
|
||||
|
||||
if (Uppercase) {
|
||||
sprintf (
|
||||
Buffer,
|
||||
"%08X-%04X-%04X-%02X%02X-%02X%02X%02X%02X%02X%02X",
|
||||
Guid->Data1,
|
||||
Guid->Data2,
|
||||
Guid->Data3,
|
||||
Guid->Data4[0],
|
||||
Guid->Data4[1],
|
||||
Guid->Data4[2],
|
||||
Guid->Data4[3],
|
||||
Guid->Data4[4],
|
||||
Guid->Data4[5],
|
||||
Guid->Data4[6],
|
||||
Guid->Data4[7]
|
||||
);
|
||||
} else {
|
||||
sprintf (
|
||||
Buffer,
|
||||
"%08x-%04x-%04x-%02x%02x-%02x%02x%02x%02x%02x%02x",
|
||||
Guid->Data1,
|
||||
Guid->Data2,
|
||||
Guid->Data3,
|
||||
Guid->Data4[0],
|
||||
Guid->Data4[1],
|
||||
Guid->Data4[2],
|
||||
Guid->Data4[3],
|
||||
Guid->Data4[4],
|
||||
Guid->Data4[5],
|
||||
Guid->Data4[6],
|
||||
Guid->Data4[7]
|
||||
);
|
||||
}
|
||||
|
||||
return EFI_SUCCESS;
|
||||
}
|
||||
|
||||
#ifdef __GNUC__
|
||||
#ifndef __CYGWIN__
|
||||
char *strlwr(char *s)
|
||||
{
|
||||
char *p = s;
|
||||
for(;*s;s++) {
|
||||
*s = tolower(*s);
|
||||
}
|
||||
return p;
|
||||
}
|
||||
#endif
|
||||
#endif
|
||||
135
Tools/CodeTools/Source/Common/CommonLib.h
Normal file
135
Tools/CodeTools/Source/Common/CommonLib.h
Normal file
@ -0,0 +1,135 @@
|
||||
/*++
|
||||
|
||||
Copyright (c) 2004, Intel Corporation
|
||||
All rights reserved. This program and the accompanying materials
|
||||
are licensed and made available under the terms and conditions of the BSD License
|
||||
which accompanies this distribution. The full text of the license may be found at
|
||||
http://opensource.org/licenses/bsd-license.php
|
||||
|
||||
THE PROGRAM IS DISTRIBUTED UNDER THE BSD LICENSE ON AN "AS IS" BASIS,
|
||||
WITHOUT WARRANTIES OR REPRESENTATIONS OF ANY KIND, EITHER EXPRESS OR IMPLIED.
|
||||
|
||||
Module Name:
|
||||
|
||||
CommonLib.h
|
||||
|
||||
Abstract:
|
||||
|
||||
Common library assistance routines.
|
||||
|
||||
--*/
|
||||
|
||||
#ifndef _EFI_COMMON_LIB_H
|
||||
#define _EFI_COMMON_LIB_H
|
||||
|
||||
#include <Common/UefiBaseTypes.h>
|
||||
|
||||
#ifndef _MAX_PATH
|
||||
#define _MAX_PATH 500
|
||||
#endif
|
||||
|
||||
#define PRINTED_GUID_BUFFER_SIZE 37 // including null-termination
|
||||
//
|
||||
// Function declarations
|
||||
//
|
||||
VOID
|
||||
PeiZeroMem (
|
||||
IN VOID *Buffer,
|
||||
IN UINTN Size
|
||||
)
|
||||
;
|
||||
|
||||
VOID
|
||||
PeiCopyMem (
|
||||
IN VOID *Destination,
|
||||
IN VOID *Source,
|
||||
IN UINTN Length
|
||||
)
|
||||
;
|
||||
|
||||
VOID
|
||||
ZeroMem (
|
||||
IN VOID *Buffer,
|
||||
IN UINTN Size
|
||||
)
|
||||
;
|
||||
|
||||
VOID
|
||||
CopyMem (
|
||||
IN VOID *Destination,
|
||||
IN VOID *Source,
|
||||
IN UINTN Length
|
||||
)
|
||||
;
|
||||
|
||||
INTN
|
||||
CompareGuid (
|
||||
IN EFI_GUID *Guid1,
|
||||
IN EFI_GUID *Guid2
|
||||
)
|
||||
;
|
||||
|
||||
EFI_STATUS
|
||||
GetFileImage (
|
||||
IN CHAR8 *InputFileName,
|
||||
OUT CHAR8 **InputFileImage,
|
||||
OUT UINT32 *BytesRead
|
||||
)
|
||||
;
|
||||
|
||||
UINT8
|
||||
CalculateChecksum8 (
|
||||
IN UINT8 *Buffer,
|
||||
IN UINTN Size
|
||||
)
|
||||
;
|
||||
|
||||
UINT8
|
||||
CalculateSum8 (
|
||||
IN UINT8 *Buffer,
|
||||
IN UINTN Size
|
||||
)
|
||||
;
|
||||
|
||||
UINT16
|
||||
CalculateChecksum16 (
|
||||
IN UINT16 *Buffer,
|
||||
IN UINTN Size
|
||||
)
|
||||
;
|
||||
|
||||
UINT16
|
||||
CalculateSum16 (
|
||||
IN UINT16 *Buffer,
|
||||
IN UINTN Size
|
||||
)
|
||||
;
|
||||
|
||||
EFI_STATUS
|
||||
PrintGuid (
|
||||
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
|
||||
)
|
||||
;
|
||||
|
||||
#define ASSERT(x) assert(x)
|
||||
|
||||
#ifdef __GNUC__
|
||||
#define stricmp strcasecmp
|
||||
#define strnicmp strncasecmp
|
||||
#define strcmpi strcasecmp
|
||||
#ifndef __CYGWIN__
|
||||
char *strlwr(char *s);
|
||||
#endif
|
||||
#endif
|
||||
|
||||
#endif
|
||||
326
Tools/CodeTools/Source/Common/Crc32.c
Normal file
326
Tools/CodeTools/Source/Common/Crc32.c
Normal file
@ -0,0 +1,326 @@
|
||||
/*++
|
||||
|
||||
Copyright (c) 2004, Intel Corporation
|
||||
All rights reserved. This program and the accompanying materials
|
||||
are licensed and made available under the terms and conditions of the BSD License
|
||||
which accompanies this distribution. The full text of the license may be found at
|
||||
http://opensource.org/licenses/bsd-license.php
|
||||
|
||||
THE PROGRAM IS DISTRIBUTED UNDER THE BSD LICENSE ON AN "AS IS" BASIS,
|
||||
WITHOUT WARRANTIES OR REPRESENTATIONS OF ANY KIND, EITHER EXPRESS OR IMPLIED.
|
||||
|
||||
Module Name:
|
||||
|
||||
crc32.c
|
||||
|
||||
Abstract:
|
||||
|
||||
CalcuateCrc32 routine.
|
||||
|
||||
--*/
|
||||
|
||||
#include <stdlib.h>
|
||||
#include "Crc32.h"
|
||||
|
||||
UINT32 mCrcTable[256] = {
|
||||
0x00000000,
|
||||
0x77073096,
|
||||
0xEE0E612C,
|
||||
0x990951BA,
|
||||
0x076DC419,
|
||||
0x706AF48F,
|
||||
0xE963A535,
|
||||
0x9E6495A3,
|
||||
0x0EDB8832,
|
||||
0x79DCB8A4,
|
||||
0xE0D5E91E,
|
||||
0x97D2D988,
|
||||
0x09B64C2B,
|
||||
0x7EB17CBD,
|
||||
0xE7B82D07,
|
||||
0x90BF1D91,
|
||||
0x1DB71064,
|
||||
0x6AB020F2,
|
||||
0xF3B97148,
|
||||
0x84BE41DE,
|
||||
0x1ADAD47D,
|
||||
0x6DDDE4EB,
|
||||
0xF4D4B551,
|
||||
0x83D385C7,
|
||||
0x136C9856,
|
||||
0x646BA8C0,
|
||||
0xFD62F97A,
|
||||
0x8A65C9EC,
|
||||
0x14015C4F,
|
||||
0x63066CD9,
|
||||
0xFA0F3D63,
|
||||
0x8D080DF5,
|
||||
0x3B6E20C8,
|
||||
0x4C69105E,
|
||||
0xD56041E4,
|
||||
0xA2677172,
|
||||
0x3C03E4D1,
|
||||
0x4B04D447,
|
||||
0xD20D85FD,
|
||||
0xA50AB56B,
|
||||
0x35B5A8FA,
|
||||
0x42B2986C,
|
||||
0xDBBBC9D6,
|
||||
0xACBCF940,
|
||||
0x32D86CE3,
|
||||
0x45DF5C75,
|
||||
0xDCD60DCF,
|
||||
0xABD13D59,
|
||||
0x26D930AC,
|
||||
0x51DE003A,
|
||||
0xC8D75180,
|
||||
0xBFD06116,
|
||||
0x21B4F4B5,
|
||||
0x56B3C423,
|
||||
0xCFBA9599,
|
||||
0xB8BDA50F,
|
||||
0x2802B89E,
|
||||
0x5F058808,
|
||||
0xC60CD9B2,
|
||||
0xB10BE924,
|
||||
0x2F6F7C87,
|
||||
0x58684C11,
|
||||
0xC1611DAB,
|
||||
0xB6662D3D,
|
||||
0x76DC4190,
|
||||
0x01DB7106,
|
||||
0x98D220BC,
|
||||
0xEFD5102A,
|
||||
0x71B18589,
|
||||
0x06B6B51F,
|
||||
0x9FBFE4A5,
|
||||
0xE8B8D433,
|
||||
0x7807C9A2,
|
||||
0x0F00F934,
|
||||
0x9609A88E,
|
||||
0xE10E9818,
|
||||
0x7F6A0DBB,
|
||||
0x086D3D2D,
|
||||
0x91646C97,
|
||||
0xE6635C01,
|
||||
0x6B6B51F4,
|
||||
0x1C6C6162,
|
||||
0x856530D8,
|
||||
0xF262004E,
|
||||
0x6C0695ED,
|
||||
0x1B01A57B,
|
||||
0x8208F4C1,
|
||||
0xF50FC457,
|
||||
0x65B0D9C6,
|
||||
0x12B7E950,
|
||||
0x8BBEB8EA,
|
||||
0xFCB9887C,
|
||||
0x62DD1DDF,
|
||||
0x15DA2D49,
|
||||
0x8CD37CF3,
|
||||
0xFBD44C65,
|
||||
0x4DB26158,
|
||||
0x3AB551CE,
|
||||
0xA3BC0074,
|
||||
0xD4BB30E2,
|
||||
0x4ADFA541,
|
||||
0x3DD895D7,
|
||||
0xA4D1C46D,
|
||||
0xD3D6F4FB,
|
||||
0x4369E96A,
|
||||
0x346ED9FC,
|
||||
0xAD678846,
|
||||
0xDA60B8D0,
|
||||
0x44042D73,
|
||||
0x33031DE5,
|
||||
0xAA0A4C5F,
|
||||
0xDD0D7CC9,
|
||||
0x5005713C,
|
||||
0x270241AA,
|
||||
0xBE0B1010,
|
||||
0xC90C2086,
|
||||
0x5768B525,
|
||||
0x206F85B3,
|
||||
0xB966D409,
|
||||
0xCE61E49F,
|
||||
0x5EDEF90E,
|
||||
0x29D9C998,
|
||||
0xB0D09822,
|
||||
0xC7D7A8B4,
|
||||
0x59B33D17,
|
||||
0x2EB40D81,
|
||||
0xB7BD5C3B,
|
||||
0xC0BA6CAD,
|
||||
0xEDB88320,
|
||||
0x9ABFB3B6,
|
||||
0x03B6E20C,
|
||||
0x74B1D29A,
|
||||
0xEAD54739,
|
||||
0x9DD277AF,
|
||||
0x04DB2615,
|
||||
0x73DC1683,
|
||||
0xE3630B12,
|
||||
0x94643B84,
|
||||
0x0D6D6A3E,
|
||||
0x7A6A5AA8,
|
||||
0xE40ECF0B,
|
||||
0x9309FF9D,
|
||||
0x0A00AE27,
|
||||
0x7D079EB1,
|
||||
0xF00F9344,
|
||||
0x8708A3D2,
|
||||
0x1E01F268,
|
||||
0x6906C2FE,
|
||||
0xF762575D,
|
||||
0x806567CB,
|
||||
0x196C3671,
|
||||
0x6E6B06E7,
|
||||
0xFED41B76,
|
||||
0x89D32BE0,
|
||||
0x10DA7A5A,
|
||||
0x67DD4ACC,
|
||||
0xF9B9DF6F,
|
||||
0x8EBEEFF9,
|
||||
0x17B7BE43,
|
||||
0x60B08ED5,
|
||||
0xD6D6A3E8,
|
||||
0xA1D1937E,
|
||||
0x38D8C2C4,
|
||||
0x4FDFF252,
|
||||
0xD1BB67F1,
|
||||
0xA6BC5767,
|
||||
0x3FB506DD,
|
||||
0x48B2364B,
|
||||
0xD80D2BDA,
|
||||
0xAF0A1B4C,
|
||||
0x36034AF6,
|
||||
0x41047A60,
|
||||
0xDF60EFC3,
|
||||
0xA867DF55,
|
||||
0x316E8EEF,
|
||||
0x4669BE79,
|
||||
0xCB61B38C,
|
||||
0xBC66831A,
|
||||
0x256FD2A0,
|
||||
0x5268E236,
|
||||
0xCC0C7795,
|
||||
0xBB0B4703,
|
||||
0x220216B9,
|
||||
0x5505262F,
|
||||
0xC5BA3BBE,
|
||||
0xB2BD0B28,
|
||||
0x2BB45A92,
|
||||
0x5CB36A04,
|
||||
0xC2D7FFA7,
|
||||
0xB5D0CF31,
|
||||
0x2CD99E8B,
|
||||
0x5BDEAE1D,
|
||||
0x9B64C2B0,
|
||||
0xEC63F226,
|
||||
0x756AA39C,
|
||||
0x026D930A,
|
||||
0x9C0906A9,
|
||||
0xEB0E363F,
|
||||
0x72076785,
|
||||
0x05005713,
|
||||
0x95BF4A82,
|
||||
0xE2B87A14,
|
||||
0x7BB12BAE,
|
||||
0x0CB61B38,
|
||||
0x92D28E9B,
|
||||
0xE5D5BE0D,
|
||||
0x7CDCEFB7,
|
||||
0x0BDBDF21,
|
||||
0x86D3D2D4,
|
||||
0xF1D4E242,
|
||||
0x68DDB3F8,
|
||||
0x1FDA836E,
|
||||
0x81BE16CD,
|
||||
0xF6B9265B,
|
||||
0x6FB077E1,
|
||||
0x18B74777,
|
||||
0x88085AE6,
|
||||
0xFF0F6A70,
|
||||
0x66063BCA,
|
||||
0x11010B5C,
|
||||
0x8F659EFF,
|
||||
0xF862AE69,
|
||||
0x616BFFD3,
|
||||
0x166CCF45,
|
||||
0xA00AE278,
|
||||
0xD70DD2EE,
|
||||
0x4E048354,
|
||||
0x3903B3C2,
|
||||
0xA7672661,
|
||||
0xD06016F7,
|
||||
0x4969474D,
|
||||
0x3E6E77DB,
|
||||
0xAED16A4A,
|
||||
0xD9D65ADC,
|
||||
0x40DF0B66,
|
||||
0x37D83BF0,
|
||||
0xA9BCAE53,
|
||||
0xDEBB9EC5,
|
||||
0x47B2CF7F,
|
||||
0x30B5FFE9,
|
||||
0xBDBDF21C,
|
||||
0xCABAC28A,
|
||||
0x53B39330,
|
||||
0x24B4A3A6,
|
||||
0xBAD03605,
|
||||
0xCDD70693,
|
||||
0x54DE5729,
|
||||
0x23D967BF,
|
||||
0xB3667A2E,
|
||||
0xC4614AB8,
|
||||
0x5D681B02,
|
||||
0x2A6F2B94,
|
||||
0xB40BBE37,
|
||||
0xC30C8EA1,
|
||||
0x5A05DF1B,
|
||||
0x2D02EF8D
|
||||
};
|
||||
|
||||
EFI_STATUS
|
||||
CalculateCrc32 (
|
||||
IN UINT8 *Data,
|
||||
IN UINTN DataSize,
|
||||
IN OUT UINT32 *CrcOut
|
||||
)
|
||||
/*++
|
||||
|
||||
Routine Description:
|
||||
|
||||
The CalculateCrc32 routine.
|
||||
|
||||
Arguments:
|
||||
|
||||
Data - The buffer contaning the data to be processed
|
||||
DataSize - The size of data to be processed
|
||||
CrcOut - A pointer to the caller allocated UINT32 that on
|
||||
contains the CRC32 checksum of Data
|
||||
|
||||
Returns:
|
||||
|
||||
EFI_SUCCESS - Calculation is successful.
|
||||
EFI_INVALID_PARAMETER - Data / CrcOut = NULL, or DataSize = 0
|
||||
|
||||
--*/
|
||||
{
|
||||
UINT32 Crc;
|
||||
UINTN Index;
|
||||
UINT8 *Ptr;
|
||||
|
||||
if ((DataSize == 0) || (Data == NULL) || (CrcOut == NULL)) {
|
||||
return EFI_INVALID_PARAMETER;
|
||||
}
|
||||
|
||||
Crc = 0xffffffff;
|
||||
for (Index = 0, Ptr = Data; Index < DataSize; Index++, Ptr++) {
|
||||
Crc = (Crc >> 8) ^ mCrcTable[(UINT8) Crc ^ *Ptr];
|
||||
}
|
||||
|
||||
*CrcOut = Crc ^ 0xffffffff;
|
||||
|
||||
return EFI_SUCCESS;
|
||||
}
|
||||
54
Tools/CodeTools/Source/Common/Crc32.h
Normal file
54
Tools/CodeTools/Source/Common/Crc32.h
Normal file
@ -0,0 +1,54 @@
|
||||
/*++
|
||||
|
||||
Copyright (c) 2004, Intel Corporation
|
||||
All rights reserved. This program and the accompanying materials
|
||||
are licensed and made available under the terms and conditions of the BSD License
|
||||
which accompanies this distribution. The full text of the license may be found at
|
||||
http://opensource.org/licenses/bsd-license.php
|
||||
|
||||
THE PROGRAM IS DISTRIBUTED UNDER THE BSD LICENSE ON AN "AS IS" BASIS,
|
||||
WITHOUT WARRANTIES OR REPRESENTATIONS OF ANY KIND, EITHER EXPRESS OR IMPLIED.
|
||||
|
||||
Module Name:
|
||||
|
||||
Crc32.h
|
||||
|
||||
Abstract:
|
||||
|
||||
Header file for CalcuateCrc32 routine
|
||||
|
||||
--*/
|
||||
|
||||
#ifndef _CRC32_H
|
||||
#define _CRC32_H
|
||||
|
||||
#include <Common/UefiBaseTypes.h>
|
||||
|
||||
EFI_STATUS
|
||||
CalculateCrc32 (
|
||||
IN UINT8 *Data,
|
||||
IN UINTN DataSize,
|
||||
IN OUT UINT32 *CrcOut
|
||||
)
|
||||
/*++
|
||||
|
||||
Routine Description:
|
||||
|
||||
The CalculateCrc32 routine.
|
||||
|
||||
Arguments:
|
||||
|
||||
Data - The buffer contaning the data to be processed
|
||||
DataSize - The size of data to be processed
|
||||
CrcOut - A pointer to the caller allocated UINT32 that on
|
||||
contains the CRC32 checksum of Data
|
||||
|
||||
Returns:
|
||||
|
||||
EFI_SUCCESS - Calculation is successful.
|
||||
EFI_INVALID_PARAMETER - Data / CrcOut = NULL, or DataSize = 0
|
||||
|
||||
--*/
|
||||
;
|
||||
|
||||
#endif
|
||||
1742
Tools/CodeTools/Source/Common/EfiCompress.c
Normal file
1742
Tools/CodeTools/Source/Common/EfiCompress.c
Normal file
File diff suppressed because it is too large
Load Diff
69
Tools/CodeTools/Source/Common/EfiCompress.h
Normal file
69
Tools/CodeTools/Source/Common/EfiCompress.h
Normal file
@ -0,0 +1,69 @@
|
||||
/*++
|
||||
|
||||
Copyright (c) 2004, Intel Corporation
|
||||
All rights reserved. This program and the accompanying materials
|
||||
are licensed and made available under the terms and conditions of the BSD License
|
||||
which accompanies this distribution. The full text of the license may be found at
|
||||
http://opensource.org/licenses/bsd-license.php
|
||||
|
||||
THE PROGRAM IS DISTRIBUTED UNDER THE BSD LICENSE ON AN "AS IS" BASIS,
|
||||
WITHOUT WARRANTIES OR REPRESENTATIONS OF ANY KIND, EITHER EXPRESS OR IMPLIED.
|
||||
|
||||
Module Name:
|
||||
|
||||
EfiCompress.h
|
||||
|
||||
Abstract:
|
||||
|
||||
Header file for compression routine
|
||||
|
||||
--*/
|
||||
|
||||
#ifndef _EFICOMPRESS_H
|
||||
#define _EFICOMPRESS_H
|
||||
|
||||
#include <string.h>
|
||||
#include <stdlib.h>
|
||||
|
||||
#include <Common/UefiBaseTypes.h>
|
||||
|
||||
EFI_STATUS
|
||||
Compress (
|
||||
IN UINT8 *SrcBuffer,
|
||||
IN UINT32 SrcSize,
|
||||
IN UINT8 *DstBuffer,
|
||||
IN OUT UINT32 *DstSize
|
||||
)
|
||||
;
|
||||
|
||||
/*++
|
||||
|
||||
Routine Description:
|
||||
|
||||
The compression routine.
|
||||
|
||||
Arguments:
|
||||
|
||||
SrcBuffer - The buffer storing the source data
|
||||
SrcSize - The size of source data
|
||||
DstBuffer - The buffer to store the compressed data
|
||||
DstSize - On input, the size of DstBuffer; On output,
|
||||
the size of the actual compressed data.
|
||||
|
||||
Returns:
|
||||
|
||||
EFI_BUFFER_TOO_SMALL - The DstBuffer is too small. In this case,
|
||||
DstSize contains the size needed.
|
||||
EFI_SUCCESS - Compression is successful.
|
||||
|
||||
--*/
|
||||
typedef
|
||||
EFI_STATUS
|
||||
(*COMPRESS_FUNCTION) (
|
||||
IN UINT8 *SrcBuffer,
|
||||
IN UINT32 SrcSize,
|
||||
IN UINT8 *DstBuffer,
|
||||
IN OUT UINT32 *DstSize
|
||||
);
|
||||
|
||||
#endif
|
||||
141
Tools/CodeTools/Source/Common/EfiCustomizedCompress.h
Normal file
141
Tools/CodeTools/Source/Common/EfiCustomizedCompress.h
Normal file
@ -0,0 +1,141 @@
|
||||
/*++
|
||||
|
||||
Copyright (c) 2004, Intel Corporation
|
||||
All rights reserved. This program and the accompanying materials
|
||||
are licensed and made available under the terms and conditions of the BSD License
|
||||
which accompanies this distribution. The full text of the license may be found at
|
||||
http://opensource.org/licenses/bsd-license.php
|
||||
|
||||
THE PROGRAM IS DISTRIBUTED UNDER THE BSD LICENSE ON AN "AS IS" BASIS,
|
||||
WITHOUT WARRANTIES OR REPRESENTATIONS OF ANY KIND, EITHER EXPRESS OR IMPLIED.
|
||||
|
||||
Module Name:
|
||||
|
||||
EfiCustomizedCompress.h
|
||||
|
||||
Abstract:
|
||||
|
||||
Header file for Customized compression routine
|
||||
|
||||
--*/
|
||||
|
||||
#ifndef _EFICUSTOMIZEDCOMPRESS_H
|
||||
#define _EFICUSTOMIZEDCOMPRESS_H
|
||||
|
||||
#include <Common/UefiBaseTypes.h>
|
||||
|
||||
EFI_STATUS
|
||||
SetCustomizedCompressionType (
|
||||
IN CHAR8 *Type
|
||||
)
|
||||
;
|
||||
|
||||
/*++
|
||||
|
||||
Routine Description:
|
||||
|
||||
The implementation of Customized SetCompressionType().
|
||||
|
||||
Arguments:
|
||||
Type - The type if compression.
|
||||
|
||||
Returns:
|
||||
|
||||
EFI_SUCCESS - The type has been set.
|
||||
EFI_UNSUPPORTED - This type is unsupported.
|
||||
|
||||
|
||||
--*/
|
||||
EFI_STATUS
|
||||
CustomizedGetInfo (
|
||||
IN VOID *Source,
|
||||
IN UINT32 SrcSize,
|
||||
OUT UINT32 *DstSize,
|
||||
OUT UINT32 *ScratchSize
|
||||
)
|
||||
;
|
||||
|
||||
/*++
|
||||
|
||||
Routine Description:
|
||||
|
||||
The implementation of Customized GetInfo().
|
||||
|
||||
Arguments:
|
||||
|
||||
Source - The source buffer containing the compressed data.
|
||||
SrcSize - The size of source buffer
|
||||
DstSize - The size of destination buffer.
|
||||
ScratchSize - The size of scratch buffer.
|
||||
|
||||
Returns:
|
||||
|
||||
EFI_SUCCESS - The size of destination buffer and the size of scratch buffer are successull retrieved.
|
||||
EFI_INVALID_PARAMETER - The source data is corrupted
|
||||
|
||||
--*/
|
||||
EFI_STATUS
|
||||
CustomizedDecompress (
|
||||
IN VOID *Source,
|
||||
IN UINT32 SrcSize,
|
||||
IN OUT VOID *Destination,
|
||||
IN UINT32 DstSize,
|
||||
IN OUT VOID *Scratch,
|
||||
IN UINT32 ScratchSize
|
||||
)
|
||||
;
|
||||
|
||||
/*++
|
||||
|
||||
Routine Description:
|
||||
|
||||
The implementation of Customized Decompress().
|
||||
|
||||
Arguments:
|
||||
|
||||
This - The protocol instance pointer
|
||||
Source - The source buffer containing the compressed data.
|
||||
SrcSize - The size of source buffer
|
||||
Destination - The destination buffer to store the decompressed data
|
||||
DstSize - The size of destination buffer.
|
||||
Scratch - The buffer used internally by the decompress routine. This buffer is needed to store intermediate data.
|
||||
ScratchSize - The size of scratch buffer.
|
||||
|
||||
Returns:
|
||||
|
||||
EFI_SUCCESS - Decompression is successfull
|
||||
EFI_INVALID_PARAMETER - The source data is corrupted
|
||||
|
||||
--*/
|
||||
EFI_STATUS
|
||||
CustomizedCompress (
|
||||
IN UINT8 *SrcBuffer,
|
||||
IN UINT32 SrcSize,
|
||||
IN UINT8 *DstBuffer,
|
||||
IN OUT UINT32 *DstSize
|
||||
)
|
||||
;
|
||||
|
||||
/*++
|
||||
|
||||
Routine Description:
|
||||
|
||||
The Customized compression routine.
|
||||
|
||||
Arguments:
|
||||
|
||||
SrcBuffer - The buffer storing the source data
|
||||
SrcSize - The size of source data
|
||||
DstBuffer - The buffer to store the compressed data
|
||||
DstSize - On input, the size of DstBuffer; On output,
|
||||
the size of the actual compressed data.
|
||||
|
||||
Returns:
|
||||
|
||||
EFI_BUFFER_TOO_SMALL - The DstBuffer is too small. In this case,
|
||||
DstSize contains the size needed.
|
||||
EFI_SUCCESS - Compression is successful.
|
||||
|
||||
--*/
|
||||
|
||||
#endif
|
||||
790
Tools/CodeTools/Source/Common/EfiDecompress.c
Normal file
790
Tools/CodeTools/Source/Common/EfiDecompress.c
Normal file
@ -0,0 +1,790 @@
|
||||
/*++
|
||||
|
||||
Copyright (c) 2004, Intel Corporation
|
||||
All rights reserved. This program and the accompanying materials
|
||||
are licensed and made available under the terms and conditions of the BSD License
|
||||
which accompanies this distribution. The full text of the license may be found at
|
||||
http://opensource.org/licenses/bsd-license.php
|
||||
|
||||
THE PROGRAM IS DISTRIBUTED UNDER THE BSD LICENSE ON AN "AS IS" BASIS,
|
||||
WITHOUT WARRANTIES OR REPRESENTATIONS OF ANY KIND, EITHER EXPRESS OR IMPLIED.
|
||||
|
||||
Module Name:
|
||||
|
||||
EfiDecompress.c
|
||||
|
||||
Abstract:
|
||||
|
||||
Decompressor. Algorithm Ported from OPSD code (Decomp.asm)
|
||||
|
||||
--*/
|
||||
|
||||
#include "EfiDecompress.h"
|
||||
|
||||
//
|
||||
// Decompression algorithm begins here
|
||||
//
|
||||
#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 PBIT 5
|
||||
#define TBIT 5
|
||||
#define MAXNP ((1U << PBIT) - 1)
|
||||
#define NT (CODE_BIT + 3)
|
||||
#if NT > MAXNP
|
||||
#define NPT NT
|
||||
#else
|
||||
#define NPT MAXNP
|
||||
#endif
|
||||
|
||||
typedef struct {
|
||||
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 mBadTableFlag;
|
||||
|
||||
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
|
||||
VOID
|
||||
FillBuf (
|
||||
IN SCRATCH_DATA *Sd,
|
||||
IN UINT16 NumOfBits
|
||||
)
|
||||
/*++
|
||||
|
||||
Routine Description:
|
||||
|
||||
Shift mBitBuf NumOfBits left. Read in NumOfBits of bits from source.
|
||||
|
||||
Arguments:
|
||||
|
||||
Sd - The global scratch data
|
||||
NumOfBit - The number of bits to shift and read.
|
||||
|
||||
Returns: (VOID)
|
||||
|
||||
--*/
|
||||
{
|
||||
Sd->mBitBuf = (UINT32) (Sd->mBitBuf << NumOfBits);
|
||||
|
||||
while (NumOfBits > Sd->mBitCount) {
|
||||
|
||||
Sd->mBitBuf |= (UINT32) (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;
|
||||
|
||||
} else {
|
||||
//
|
||||
// No more bits from the source, just pad zero bit.
|
||||
//
|
||||
Sd->mSubBitBuf = 0;
|
||||
Sd->mBitCount = 8;
|
||||
|
||||
}
|
||||
}
|
||||
|
||||
Sd->mBitCount = (UINT16) (Sd->mBitCount - NumOfBits);
|
||||
Sd->mBitBuf |= Sd->mSubBitBuf >> Sd->mBitCount;
|
||||
}
|
||||
|
||||
STATIC
|
||||
UINT32
|
||||
GetBits (
|
||||
IN SCRATCH_DATA *Sd,
|
||||
IN UINT16 NumOfBits
|
||||
)
|
||||
/*++
|
||||
|
||||
Routine Description:
|
||||
|
||||
Get NumOfBits of bits out from mBitBuf. Fill mBitBuf with subsequent
|
||||
NumOfBits of bits from source. Returns NumOfBits of bits that are
|
||||
popped out.
|
||||
|
||||
Arguments:
|
||||
|
||||
Sd - The global scratch data.
|
||||
NumOfBits - The number of bits to pop and read.
|
||||
|
||||
Returns:
|
||||
|
||||
The bits that are popped out.
|
||||
|
||||
--*/
|
||||
{
|
||||
UINT32 OutBits;
|
||||
|
||||
OutBits = (UINT32) (Sd->mBitBuf >> (BITBUFSIZ - NumOfBits));
|
||||
|
||||
FillBuf (Sd, NumOfBits);
|
||||
|
||||
return OutBits;
|
||||
}
|
||||
|
||||
STATIC
|
||||
UINT16
|
||||
MakeTable (
|
||||
IN SCRATCH_DATA *Sd,
|
||||
IN UINT16 NumOfChar,
|
||||
IN UINT8 *BitLen,
|
||||
IN UINT16 TableBits,
|
||||
OUT UINT16 *Table
|
||||
)
|
||||
/*++
|
||||
|
||||
Routine Description:
|
||||
|
||||
Creates Huffman Code mapping table according to code length array.
|
||||
|
||||
Arguments:
|
||||
|
||||
Sd - The global scratch data
|
||||
NumOfChar - Number of symbols in the symbol set
|
||||
BitLen - Code length array
|
||||
TableBits - The width of the mapping table
|
||||
Table - The table
|
||||
|
||||
Returns:
|
||||
|
||||
0 - OK.
|
||||
BAD_TABLE - The table is corrupted.
|
||||
|
||||
--*/
|
||||
{
|
||||
UINT16 Count[17];
|
||||
UINT16 Weight[17];
|
||||
UINT16 Start[18];
|
||||
UINT16 *Pointer;
|
||||
UINT16 Index3;
|
||||
UINT16 Index;
|
||||
UINT16 Len;
|
||||
UINT16 Char;
|
||||
UINT16 JuBits;
|
||||
UINT16 Avail;
|
||||
UINT16 NextCode;
|
||||
UINT16 Mask;
|
||||
|
||||
for (Index = 1; Index <= 16; Index++) {
|
||||
Count[Index] = 0;
|
||||
}
|
||||
|
||||
for (Index = 0; Index < NumOfChar; Index++) {
|
||||
Count[BitLen[Index]]++;
|
||||
}
|
||||
|
||||
Start[1] = 0;
|
||||
|
||||
for (Index = 1; Index <= 16; Index++) {
|
||||
Start[Index + 1] = (UINT16) (Start[Index] + (Count[Index] << (16 - Index)));
|
||||
}
|
||||
|
||||
if (Start[17] != 0) {
|
||||
/*(1U << 16)*/
|
||||
return (UINT16) BAD_TABLE;
|
||||
}
|
||||
|
||||
JuBits = (UINT16) (16 - TableBits);
|
||||
|
||||
for (Index = 1; Index <= TableBits; Index++) {
|
||||
Start[Index] >>= JuBits;
|
||||
Weight[Index] = (UINT16) (1U << (TableBits - Index));
|
||||
}
|
||||
|
||||
while (Index <= 16) {
|
||||
Weight[Index++] = (UINT16) (1U << (16 - Index));
|
||||
}
|
||||
|
||||
Index = (UINT16) (Start[TableBits + 1] >> JuBits);
|
||||
|
||||
if (Index != 0) {
|
||||
Index3 = (UINT16) (1U << TableBits);
|
||||
while (Index != Index3) {
|
||||
Table[Index++] = 0;
|
||||
}
|
||||
}
|
||||
|
||||
Avail = NumOfChar;
|
||||
Mask = (UINT16) (1U << (15 - TableBits));
|
||||
|
||||
for (Char = 0; Char < NumOfChar; Char++) {
|
||||
|
||||
Len = BitLen[Char];
|
||||
if (Len == 0) {
|
||||
continue;
|
||||
}
|
||||
|
||||
NextCode = (UINT16) (Start[Len] + Weight[Len]);
|
||||
|
||||
if (Len <= TableBits) {
|
||||
|
||||
for (Index = Start[Len]; Index < NextCode; Index++) {
|
||||
Table[Index] = Char;
|
||||
}
|
||||
|
||||
} else {
|
||||
|
||||
Index3 = Start[Len];
|
||||
Pointer = &Table[Index3 >> JuBits];
|
||||
Index = (UINT16) (Len - TableBits);
|
||||
|
||||
while (Index != 0) {
|
||||
if (*Pointer == 0) {
|
||||
Sd->mRight[Avail] = Sd->mLeft[Avail] = 0;
|
||||
*Pointer = Avail++;
|
||||
}
|
||||
|
||||
if (Index3 & Mask) {
|
||||
Pointer = &Sd->mRight[*Pointer];
|
||||
} else {
|
||||
Pointer = &Sd->mLeft[*Pointer];
|
||||
}
|
||||
|
||||
Index3 <<= 1;
|
||||
Index--;
|
||||
}
|
||||
|
||||
*Pointer = Char;
|
||||
|
||||
}
|
||||
|
||||
Start[Len] = NextCode;
|
||||
}
|
||||
//
|
||||
// Succeeds
|
||||
//
|
||||
return 0;
|
||||
}
|
||||
|
||||
STATIC
|
||||
UINT32
|
||||
DecodeP (
|
||||
IN SCRATCH_DATA *Sd
|
||||
)
|
||||
/*++
|
||||
|
||||
Routine Description:
|
||||
|
||||
Decodes a position value.
|
||||
|
||||
Arguments:
|
||||
|
||||
Sd - the global scratch data
|
||||
|
||||
Returns:
|
||||
|
||||
The position value decoded.
|
||||
|
||||
--*/
|
||||
{
|
||||
UINT16 Val;
|
||||
UINT32 Mask;
|
||||
UINT32 Pos;
|
||||
|
||||
Val = Sd->mPTTable[Sd->mBitBuf >> (BITBUFSIZ - 8)];
|
||||
|
||||
if (Val >= MAXNP) {
|
||||
Mask = 1U << (BITBUFSIZ - 1 - 8);
|
||||
|
||||
do {
|
||||
|
||||
if (Sd->mBitBuf & Mask) {
|
||||
Val = Sd->mRight[Val];
|
||||
} else {
|
||||
Val = Sd->mLeft[Val];
|
||||
}
|
||||
|
||||
Mask >>= 1;
|
||||
} while (Val >= MAXNP);
|
||||
}
|
||||
//
|
||||
// Advance what we have read
|
||||
//
|
||||
FillBuf (Sd, Sd->mPTLen[Val]);
|
||||
|
||||
Pos = Val;
|
||||
if (Val > 1) {
|
||||
Pos = (UINT32) ((1U << (Val - 1)) + GetBits (Sd, (UINT16) (Val - 1)));
|
||||
}
|
||||
|
||||
return Pos;
|
||||
}
|
||||
|
||||
STATIC
|
||||
UINT16
|
||||
ReadPTLen (
|
||||
IN SCRATCH_DATA *Sd,
|
||||
IN UINT16 nn,
|
||||
IN UINT16 nbit,
|
||||
IN UINT16 Special
|
||||
)
|
||||
/*++
|
||||
|
||||
Routine Description:
|
||||
|
||||
Reads code lengths for the Extra Set or the Position Set
|
||||
|
||||
Arguments:
|
||||
|
||||
Sd - The global scratch data
|
||||
nn - Number of symbols
|
||||
nbit - Number of bits needed to represent nn
|
||||
Special - The special symbol that needs to be taken care of
|
||||
|
||||
Returns:
|
||||
|
||||
0 - OK.
|
||||
BAD_TABLE - Table is corrupted.
|
||||
|
||||
--*/
|
||||
{
|
||||
UINT16 Number;
|
||||
UINT16 CharC;
|
||||
UINT16 Index;
|
||||
UINT32 Mask;
|
||||
|
||||
Number = (UINT16) GetBits (Sd, nbit);
|
||||
|
||||
if (Number == 0) {
|
||||
CharC = (UINT16) GetBits (Sd, nbit);
|
||||
|
||||
for (Index = 0; Index < 256; Index++) {
|
||||
Sd->mPTTable[Index] = CharC;
|
||||
}
|
||||
|
||||
for (Index = 0; Index < nn; Index++) {
|
||||
Sd->mPTLen[Index] = 0;
|
||||
}
|
||||
|
||||
return 0;
|
||||
}
|
||||
|
||||
Index = 0;
|
||||
|
||||
while (Index < Number) {
|
||||
|
||||
CharC = (UINT16) (Sd->mBitBuf >> (BITBUFSIZ - 3));
|
||||
|
||||
if (CharC == 7) {
|
||||
Mask = 1U << (BITBUFSIZ - 1 - 3);
|
||||
while (Mask & Sd->mBitBuf) {
|
||||
Mask >>= 1;
|
||||
CharC += 1;
|
||||
}
|
||||
}
|
||||
|
||||
FillBuf (Sd, (UINT16) ((CharC < 7) ? 3 : CharC - 3));
|
||||
|
||||
Sd->mPTLen[Index++] = (UINT8) CharC;
|
||||
|
||||
if (Index == Special) {
|
||||
CharC = (UINT16) GetBits (Sd, 2);
|
||||
CharC--;
|
||||
while ((INT16) (CharC) >= 0) {
|
||||
Sd->mPTLen[Index++] = 0;
|
||||
CharC--;
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
while (Index < nn) {
|
||||
Sd->mPTLen[Index++] = 0;
|
||||
}
|
||||
|
||||
return MakeTable (Sd, nn, Sd->mPTLen, 8, Sd->mPTTable);
|
||||
}
|
||||
|
||||
STATIC
|
||||
VOID
|
||||
ReadCLen (
|
||||
SCRATCH_DATA *Sd
|
||||
)
|
||||
/*++
|
||||
|
||||
Routine Description:
|
||||
|
||||
Reads code lengths for Char&Len Set.
|
||||
|
||||
Arguments:
|
||||
|
||||
Sd - the global scratch data
|
||||
|
||||
Returns: (VOID)
|
||||
|
||||
--*/
|
||||
{
|
||||
UINT16 Number;
|
||||
UINT16 CharC;
|
||||
UINT16 Index;
|
||||
UINT32 Mask;
|
||||
|
||||
Number = (UINT16) GetBits (Sd, CBIT);
|
||||
|
||||
if (Number == 0) {
|
||||
CharC = (UINT16) GetBits (Sd, CBIT);
|
||||
|
||||
for (Index = 0; Index < NC; Index++) {
|
||||
Sd->mCLen[Index] = 0;
|
||||
}
|
||||
|
||||
for (Index = 0; Index < 4096; Index++) {
|
||||
Sd->mCTable[Index] = CharC;
|
||||
}
|
||||
|
||||
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 {
|
||||
CharC = Sd->mLeft[CharC];
|
||||
}
|
||||
|
||||
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);
|
||||
} else if (CharC == 2) {
|
||||
CharC = (UINT16) (GetBits (Sd, CBIT) + 20);
|
||||
}
|
||||
|
||||
CharC--;
|
||||
while ((INT16) (CharC) >= 0) {
|
||||
Sd->mCLen[Index++] = 0;
|
||||
CharC--;
|
||||
}
|
||||
|
||||
} else {
|
||||
|
||||
Sd->mCLen[Index++] = (UINT8) (CharC - 2);
|
||||
|
||||
}
|
||||
}
|
||||
|
||||
while (Index < NC) {
|
||||
Sd->mCLen[Index++] = 0;
|
||||
}
|
||||
|
||||
MakeTable (Sd, NC, Sd->mCLen, 12, Sd->mCTable);
|
||||
|
||||
return ;
|
||||
}
|
||||
|
||||
STATIC
|
||||
UINT16
|
||||
DecodeC (
|
||||
SCRATCH_DATA *Sd
|
||||
)
|
||||
/*++
|
||||
|
||||
Routine Description:
|
||||
|
||||
Decode a character/length value.
|
||||
|
||||
Arguments:
|
||||
|
||||
Sd - The global scratch data.
|
||||
|
||||
Returns:
|
||||
|
||||
The value decoded.
|
||||
|
||||
--*/
|
||||
{
|
||||
UINT16 Index2;
|
||||
UINT32 Mask;
|
||||
|
||||
if (Sd->mBlockSize == 0) {
|
||||
//
|
||||
// Starting a new block
|
||||
//
|
||||
Sd->mBlockSize = (UINT16) GetBits (Sd, 16);
|
||||
Sd->mBadTableFlag = ReadPTLen (Sd, NT, TBIT, 3);
|
||||
if (Sd->mBadTableFlag != 0) {
|
||||
return 0;
|
||||
}
|
||||
|
||||
ReadCLen (Sd);
|
||||
|
||||
Sd->mBadTableFlag = ReadPTLen (Sd, MAXNP, PBIT, (UINT16) (-1));
|
||||
if (Sd->mBadTableFlag != 0) {
|
||||
return 0;
|
||||
}
|
||||
}
|
||||
|
||||
Sd->mBlockSize--;
|
||||
Index2 = Sd->mCTable[Sd->mBitBuf >> (BITBUFSIZ - 12)];
|
||||
|
||||
if (Index2 >= NC) {
|
||||
Mask = 1U << (BITBUFSIZ - 1 - 12);
|
||||
|
||||
do {
|
||||
if (Sd->mBitBuf & Mask) {
|
||||
Index2 = Sd->mRight[Index2];
|
||||
} else {
|
||||
Index2 = Sd->mLeft[Index2];
|
||||
}
|
||||
|
||||
Mask >>= 1;
|
||||
} while (Index2 >= NC);
|
||||
}
|
||||
//
|
||||
// Advance what we have read
|
||||
//
|
||||
FillBuf (Sd, Sd->mCLen[Index2]);
|
||||
|
||||
return Index2;
|
||||
}
|
||||
|
||||
STATIC
|
||||
VOID
|
||||
Decode (
|
||||
SCRATCH_DATA *Sd
|
||||
)
|
||||
/*++
|
||||
|
||||
Routine Description:
|
||||
|
||||
Decode the source data and put the resulting data into the destination buffer.
|
||||
|
||||
Arguments:
|
||||
|
||||
Sd - The global scratch data
|
||||
|
||||
Returns: (VOID)
|
||||
|
||||
--*/
|
||||
{
|
||||
UINT16 BytesRemain;
|
||||
UINT32 DataIdx;
|
||||
UINT16 CharC;
|
||||
|
||||
BytesRemain = (UINT16) (-1);
|
||||
|
||||
DataIdx = 0;
|
||||
|
||||
for (;;) {
|
||||
CharC = DecodeC (Sd);
|
||||
if (Sd->mBadTableFlag != 0) {
|
||||
return ;
|
||||
}
|
||||
|
||||
if (CharC < 256) {
|
||||
//
|
||||
// Process an Original character
|
||||
//
|
||||
Sd->mDstBase[Sd->mOutBuf++] = (UINT8) CharC;
|
||||
if (Sd->mOutBuf >= Sd->mOrigSize) {
|
||||
return ;
|
||||
}
|
||||
|
||||
} else {
|
||||
//
|
||||
// Process a Pointer
|
||||
//
|
||||
CharC = (UINT16) (CharC - (UINT8_MAX + 1 - THRESHOLD));
|
||||
|
||||
BytesRemain = CharC;
|
||||
|
||||
DataIdx = Sd->mOutBuf - DecodeP (Sd) - 1;
|
||||
|
||||
BytesRemain--;
|
||||
while ((INT16) (BytesRemain) >= 0) {
|
||||
Sd->mDstBase[Sd->mOutBuf++] = Sd->mDstBase[DataIdx++];
|
||||
if (Sd->mOutBuf >= Sd->mOrigSize) {
|
||||
return ;
|
||||
}
|
||||
|
||||
BytesRemain--;
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
return ;
|
||||
}
|
||||
|
||||
EFI_STATUS
|
||||
GetInfo (
|
||||
IN VOID *Source,
|
||||
IN UINT32 SrcSize,
|
||||
OUT UINT32 *DstSize,
|
||||
OUT UINT32 *ScratchSize
|
||||
)
|
||||
/*++
|
||||
|
||||
Routine Description:
|
||||
|
||||
The implementation of EFI_DECOMPRESS_PROTOCOL.GetInfo().
|
||||
|
||||
Arguments:
|
||||
|
||||
Source - The source buffer containing the compressed data.
|
||||
SrcSize - The size of source buffer
|
||||
DstSize - The size of destination buffer.
|
||||
ScratchSize - The size of scratch buffer.
|
||||
|
||||
Returns:
|
||||
|
||||
EFI_SUCCESS - The size of destination buffer and the size of scratch buffer are successull retrieved.
|
||||
EFI_INVALID_PARAMETER - The source data is corrupted
|
||||
|
||||
--*/
|
||||
{
|
||||
UINT8 *Src;
|
||||
|
||||
*ScratchSize = sizeof (SCRATCH_DATA);
|
||||
|
||||
Src = Source;
|
||||
if (SrcSize < 8) {
|
||||
return EFI_INVALID_PARAMETER;
|
||||
}
|
||||
|
||||
*DstSize = Src[4] + (Src[5] << 8) + (Src[6] << 16) + (Src[7] << 24);
|
||||
return EFI_SUCCESS;
|
||||
}
|
||||
|
||||
EFI_STATUS
|
||||
Decompress (
|
||||
IN VOID *Source,
|
||||
IN UINT32 SrcSize,
|
||||
IN OUT VOID *Destination,
|
||||
IN UINT32 DstSize,
|
||||
IN OUT VOID *Scratch,
|
||||
IN UINT32 ScratchSize
|
||||
)
|
||||
/*++
|
||||
|
||||
Routine Description:
|
||||
|
||||
The implementation of EFI_DECOMPRESS_PROTOCOL.Decompress().
|
||||
|
||||
Arguments:
|
||||
|
||||
This - The protocol instance pointer
|
||||
Source - The source buffer containing the compressed data.
|
||||
SrcSize - The size of source buffer
|
||||
Destination - The destination buffer to store the decompressed data
|
||||
DstSize - The size of destination buffer.
|
||||
Scratch - The buffer used internally by the decompress routine. This buffer is needed to store intermediate data.
|
||||
ScratchSize - The size of scratch buffer.
|
||||
|
||||
Returns:
|
||||
|
||||
EFI_SUCCESS - Decompression is successfull
|
||||
EFI_INVALID_PARAMETER - The source data is corrupted
|
||||
|
||||
--*/
|
||||
{
|
||||
UINT32 Index;
|
||||
UINT32 CompSize;
|
||||
UINT32 OrigSize;
|
||||
EFI_STATUS Status;
|
||||
SCRATCH_DATA *Sd;
|
||||
UINT8 *Src;
|
||||
UINT8 *Dst;
|
||||
|
||||
Status = EFI_SUCCESS;
|
||||
Src = Source;
|
||||
Dst = Destination;
|
||||
|
||||
if (ScratchSize < sizeof (SCRATCH_DATA)) {
|
||||
return EFI_INVALID_PARAMETER;
|
||||
}
|
||||
|
||||
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);
|
||||
|
||||
if (SrcSize < CompSize + 8) {
|
||||
return EFI_INVALID_PARAMETER;
|
||||
}
|
||||
|
||||
if (DstSize != OrigSize) {
|
||||
return EFI_INVALID_PARAMETER;
|
||||
}
|
||||
|
||||
Src = Src + 8;
|
||||
|
||||
for (Index = 0; Index < sizeof (SCRATCH_DATA); Index++) {
|
||||
((UINT8 *) Sd)[Index] = 0;
|
||||
}
|
||||
|
||||
Sd->mSrcBase = Src;
|
||||
Sd->mDstBase = Dst;
|
||||
Sd->mCompSize = CompSize;
|
||||
Sd->mOrigSize = OrigSize;
|
||||
|
||||
//
|
||||
// Fill the first BITBUFSIZ bits
|
||||
//
|
||||
FillBuf (Sd, BITBUFSIZ);
|
||||
|
||||
//
|
||||
// Decompress it
|
||||
//
|
||||
Decode (Sd);
|
||||
|
||||
if (Sd->mBadTableFlag != 0) {
|
||||
//
|
||||
// Something wrong with the source
|
||||
//
|
||||
Status = EFI_INVALID_PARAMETER;
|
||||
}
|
||||
|
||||
return Status;
|
||||
}
|
||||
106
Tools/CodeTools/Source/Common/EfiDecompress.h
Normal file
106
Tools/CodeTools/Source/Common/EfiDecompress.h
Normal file
@ -0,0 +1,106 @@
|
||||
/*++
|
||||
|
||||
Copyright (c) 2004, Intel Corporation
|
||||
All rights reserved. This program and the accompanying materials
|
||||
are licensed and made available under the terms and conditions of the BSD License
|
||||
which accompanies this distribution. The full text of the license may be found at
|
||||
http://opensource.org/licenses/bsd-license.php
|
||||
|
||||
THE PROGRAM IS DISTRIBUTED UNDER THE BSD LICENSE ON AN "AS IS" BASIS,
|
||||
WITHOUT WARRANTIES OR REPRESENTATIONS OF ANY KIND, EITHER EXPRESS OR IMPLIED.
|
||||
|
||||
Module Name:
|
||||
|
||||
EfiDecompress.h
|
||||
|
||||
Abstract:
|
||||
|
||||
Header file for compression routine
|
||||
|
||||
--*/
|
||||
|
||||
#ifndef _EFI_DECOMPRESS_H
|
||||
#define _EFI_DECOMPRESS_H
|
||||
|
||||
#include <Common/UefiBaseTypes.h>
|
||||
|
||||
EFI_STATUS
|
||||
GetInfo (
|
||||
IN VOID *Source,
|
||||
IN UINT32 SrcSize,
|
||||
OUT UINT32 *DstSize,
|
||||
OUT UINT32 *ScratchSize
|
||||
);
|
||||
|
||||
/*++
|
||||
|
||||
Routine Description:
|
||||
|
||||
The implementation of EFI_DECOMPRESS_PROTOCOL.GetInfo().
|
||||
|
||||
Arguments:
|
||||
|
||||
Source - The source buffer containing the compressed data.
|
||||
SrcSize - The size of source buffer
|
||||
DstSize - The size of destination buffer.
|
||||
ScratchSize - The size of scratch buffer.
|
||||
|
||||
Returns:
|
||||
|
||||
EFI_SUCCESS - The size of destination buffer and the size of scratch buffer are successull retrieved.
|
||||
EFI_INVALID_PARAMETER - The source data is corrupted
|
||||
|
||||
--*/
|
||||
EFI_STATUS
|
||||
Decompress (
|
||||
IN VOID *Source,
|
||||
IN UINT32 SrcSize,
|
||||
IN OUT VOID *Destination,
|
||||
IN UINT32 DstSize,
|
||||
IN OUT VOID *Scratch,
|
||||
IN UINT32 ScratchSize
|
||||
)
|
||||
;
|
||||
|
||||
/*++
|
||||
|
||||
Routine Description:
|
||||
|
||||
The implementation of EFI_DECOMPRESS_PROTOCOL.Decompress().
|
||||
|
||||
Arguments:
|
||||
|
||||
This - The protocol instance pointer
|
||||
Source - The source buffer containing the compressed data.
|
||||
SrcSize - The size of source buffer
|
||||
Destination - The destination buffer to store the decompressed data
|
||||
DstSize - The size of destination buffer.
|
||||
Scratch - The buffer used internally by the decompress routine. This buffer is needed to store intermediate data.
|
||||
ScratchSize - The size of scratch buffer.
|
||||
|
||||
Returns:
|
||||
|
||||
EFI_SUCCESS - Decompression is successfull
|
||||
EFI_INVALID_PARAMETER - The source data is corrupted
|
||||
|
||||
--*/
|
||||
typedef
|
||||
EFI_STATUS
|
||||
(*GETINFO_FUNCTION) (
|
||||
IN VOID *Source,
|
||||
IN UINT32 SrcSize,
|
||||
OUT UINT32 *DstSize,
|
||||
OUT UINT32 *ScratchSize
|
||||
);
|
||||
|
||||
typedef
|
||||
EFI_STATUS
|
||||
(*DECOMPRESS_FUNCTION) (
|
||||
IN VOID *Source,
|
||||
IN UINT32 SrcSize,
|
||||
IN OUT VOID *Destination,
|
||||
IN UINT32 DstSize,
|
||||
IN OUT VOID *Scratch,
|
||||
IN UINT32 ScratchSize
|
||||
);
|
||||
#endif
|
||||
755
Tools/CodeTools/Source/Common/EfiUtilityMsgs.c
Normal file
755
Tools/CodeTools/Source/Common/EfiUtilityMsgs.c
Normal file
@ -0,0 +1,755 @@
|
||||
/*++
|
||||
|
||||
Copyright (c) 2004, Intel Corporation
|
||||
All rights reserved. This program and the accompanying materials
|
||||
are licensed and made available under the terms and conditions of the BSD License
|
||||
which accompanies this distribution. The full text of the license may be found at
|
||||
http://opensource.org/licenses/bsd-license.php
|
||||
|
||||
THE PROGRAM IS DISTRIBUTED UNDER THE BSD LICENSE ON AN "AS IS" BASIS,
|
||||
WITHOUT WARRANTIES OR REPRESENTATIONS OF ANY KIND, EITHER EXPRESS OR IMPLIED.
|
||||
|
||||
Module Name:
|
||||
|
||||
EfiUtilityMsgs.c
|
||||
|
||||
Abstract:
|
||||
|
||||
EFI tools utility functions to display warning, error, and informational
|
||||
messages.
|
||||
|
||||
--*/
|
||||
|
||||
#include <stdio.h>
|
||||
#include <string.h>
|
||||
#include <ctype.h>
|
||||
#include <stdarg.h>
|
||||
|
||||
#include "EfiUtilityMsgs.h"
|
||||
|
||||
#define MAX_LINE_LEN 200
|
||||
|
||||
//
|
||||
// Declare module globals for keeping track of the the utility's
|
||||
// name and other settings.
|
||||
//
|
||||
static STATUS mStatus = STATUS_SUCCESS;
|
||||
static CHAR8 mUtilityName[50] = { 0 };
|
||||
static UINT32 mDebugMsgMask = 0;
|
||||
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
|
||||
PrintMessage (
|
||||
CHAR8 *Type,
|
||||
CHAR8 *FileName,
|
||||
UINT32 LineNumber,
|
||||
UINT32 MessageCode,
|
||||
CHAR8 *Text,
|
||||
CHAR8 *MsgFmt,
|
||||
va_list List
|
||||
);
|
||||
|
||||
static
|
||||
void
|
||||
PrintLimitExceeded (
|
||||
VOID
|
||||
);
|
||||
|
||||
void
|
||||
Error (
|
||||
CHAR8 *FileName,
|
||||
UINT32 LineNumber,
|
||||
UINT32 MessageCode,
|
||||
CHAR8 *Text,
|
||||
CHAR8 *MsgFmt,
|
||||
...
|
||||
)
|
||||
/*++
|
||||
|
||||
Routine Description:
|
||||
Prints an error message.
|
||||
|
||||
Arguments:
|
||||
All arguments are optional, though the printed message may be useless if
|
||||
at least something valid is not specified.
|
||||
|
||||
FileName - name of the file or application. If not specified, then the
|
||||
utilty name (as set by the utility calling SetUtilityName()
|
||||
earlier) is used. Otherwise "Unknown utility" is used.
|
||||
|
||||
LineNumber - the line number of error, typically used by parsers. If the
|
||||
utility is not a parser, then 0 should be specified. Otherwise
|
||||
the FileName and LineNumber info can be used to cause
|
||||
MS Visual Studio to jump to the error.
|
||||
|
||||
MessageCode - an application-specific error code that can be referenced in
|
||||
other documentation.
|
||||
|
||||
Text - the text in question, typically used by parsers.
|
||||
|
||||
MsgFmt - the format string for the error message. Can contain formatting
|
||||
controls for use with the varargs.
|
||||
|
||||
Returns:
|
||||
None.
|
||||
|
||||
Notes:
|
||||
We print the following (similar to the Warn() and Debug()
|
||||
W
|
||||
Typical error/warning message format:
|
||||
|
||||
bin\VfrCompile.cpp(330) : error C2660: 'AddVfrDataStructField' : function does not take 2 parameters
|
||||
|
||||
BUGBUG -- these three utility functions are almost identical, and
|
||||
should be modified to share code.
|
||||
|
||||
Visual Studio does not find error messages with:
|
||||
|
||||
" error :"
|
||||
" error 1:"
|
||||
" error c1:"
|
||||
" error 1000:"
|
||||
" error c100:"
|
||||
|
||||
It does find:
|
||||
" error c1000:"
|
||||
--*/
|
||||
{
|
||||
va_list List;
|
||||
//
|
||||
// If limits have been set, then check that we have not exceeded them
|
||||
//
|
||||
if (mPrintLimitsSet) {
|
||||
//
|
||||
// See if we've exceeded our total count
|
||||
//
|
||||
if (mMaxWarningsPlusErrors != 0) {
|
||||
if (mErrorCount + mWarningCount > mMaxWarningsPlusErrors) {
|
||||
PrintLimitExceeded ();
|
||||
return ;
|
||||
}
|
||||
}
|
||||
//
|
||||
// See if we've exceeded our error count
|
||||
//
|
||||
if (mMaxErrors != 0) {
|
||||
if (mErrorCount > mMaxErrors) {
|
||||
PrintLimitExceeded ();
|
||||
return ;
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
mErrorCount++;
|
||||
va_start (List, MsgFmt);
|
||||
PrintMessage ("error", FileName, LineNumber, MessageCode, Text, MsgFmt, List);
|
||||
va_end (List);
|
||||
//
|
||||
// Set status accordingly
|
||||
//
|
||||
if (mStatus < STATUS_ERROR) {
|
||||
mStatus = STATUS_ERROR;
|
||||
}
|
||||
}
|
||||
|
||||
void
|
||||
ParserError (
|
||||
UINT32 MessageCode,
|
||||
CHAR8 *Text,
|
||||
CHAR8 *MsgFmt,
|
||||
...
|
||||
)
|
||||
/*++
|
||||
|
||||
Routine Description:
|
||||
Print a parser error, using the source file name and line number
|
||||
set by a previous call to SetParserPosition().
|
||||
|
||||
Arguments:
|
||||
MessageCode - application-specific error code
|
||||
Text - text to print in the error message
|
||||
MsgFmt - format string to print at the end of the error message
|
||||
|
||||
Returns:
|
||||
NA
|
||||
|
||||
--*/
|
||||
{
|
||||
va_list List;
|
||||
//
|
||||
// If limits have been set, then check them
|
||||
//
|
||||
if (mPrintLimitsSet) {
|
||||
//
|
||||
// See if we've exceeded our total count
|
||||
//
|
||||
if (mMaxWarningsPlusErrors != 0) {
|
||||
if (mErrorCount + mWarningCount > mMaxWarningsPlusErrors) {
|
||||
PrintLimitExceeded ();
|
||||
return ;
|
||||
}
|
||||
}
|
||||
//
|
||||
// See if we've exceeded our error count
|
||||
//
|
||||
if (mMaxErrors != 0) {
|
||||
if (mErrorCount > mMaxErrors) {
|
||||
PrintLimitExceeded ();
|
||||
return ;
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
mErrorCount++;
|
||||
va_start (List, MsgFmt);
|
||||
PrintMessage ("error", mSourceFileName, mSourceFileLineNum, MessageCode, Text, MsgFmt, List);
|
||||
va_end (List);
|
||||
//
|
||||
// Set status accordingly
|
||||
//
|
||||
if (mStatus < STATUS_ERROR) {
|
||||
mStatus = STATUS_ERROR;
|
||||
}
|
||||
}
|
||||
|
||||
void
|
||||
ParserWarning (
|
||||
UINT32 ErrorCode,
|
||||
CHAR8 *OffendingText,
|
||||
CHAR8 *MsgFmt,
|
||||
...
|
||||
)
|
||||
/*++
|
||||
|
||||
Routine Description:
|
||||
Print a parser warning, using the source file name and line number
|
||||
set by a previous call to SetParserPosition().
|
||||
|
||||
Arguments:
|
||||
ErrorCode - application-specific error code
|
||||
OffendingText - text to print in the warning message
|
||||
MsgFmt - format string to print at the end of the warning message
|
||||
|
||||
Returns:
|
||||
NA
|
||||
|
||||
--*/
|
||||
{
|
||||
va_list List;
|
||||
//
|
||||
// If limits have been set, then check them
|
||||
//
|
||||
if (mPrintLimitsSet) {
|
||||
//
|
||||
// See if we've exceeded our total count
|
||||
//
|
||||
if (mMaxWarningsPlusErrors != 0) {
|
||||
if (mErrorCount + mWarningCount > mMaxWarningsPlusErrors) {
|
||||
PrintLimitExceeded ();
|
||||
return ;
|
||||
}
|
||||
}
|
||||
//
|
||||
// See if we've exceeded our warning count
|
||||
//
|
||||
if (mMaxWarnings != 0) {
|
||||
if (mWarningCount > mMaxWarnings) {
|
||||
PrintLimitExceeded ();
|
||||
return ;
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
mWarningCount++;
|
||||
va_start (List, MsgFmt);
|
||||
PrintMessage ("warning", mSourceFileName, mSourceFileLineNum, ErrorCode, OffendingText, MsgFmt, List);
|
||||
va_end (List);
|
||||
//
|
||||
// Set status accordingly
|
||||
//
|
||||
if (mStatus < STATUS_WARNING) {
|
||||
mStatus = STATUS_WARNING;
|
||||
}
|
||||
}
|
||||
|
||||
void
|
||||
Warning (
|
||||
CHAR8 *FileName,
|
||||
UINT32 LineNumber,
|
||||
UINT32 MessageCode,
|
||||
CHAR8 *Text,
|
||||
CHAR8 *MsgFmt,
|
||||
...
|
||||
)
|
||||
/*++
|
||||
|
||||
Routine Description:
|
||||
Print a warning message.
|
||||
|
||||
Arguments:
|
||||
FileName - name of the file where the warning was detected, or the name
|
||||
of the application that detected the warning
|
||||
|
||||
LineNumber - the line number where the warning was detected (parsers).
|
||||
0 should be specified if the utility is not a parser.
|
||||
|
||||
MessageCode - an application-specific warning code that can be referenced in
|
||||
other documentation.
|
||||
|
||||
Text - the text in question (parsers)
|
||||
|
||||
MsgFmt - the format string for the warning message. Can contain formatting
|
||||
controls for use with varargs.
|
||||
|
||||
Returns:
|
||||
None.
|
||||
|
||||
--*/
|
||||
{
|
||||
va_list List;
|
||||
//
|
||||
// If limits have been set, then check them
|
||||
//
|
||||
if (mPrintLimitsSet) {
|
||||
//
|
||||
// See if we've exceeded our total count
|
||||
//
|
||||
if (mMaxWarningsPlusErrors != 0) {
|
||||
if (mErrorCount + mWarningCount > mMaxWarningsPlusErrors) {
|
||||
PrintLimitExceeded ();
|
||||
return ;
|
||||
}
|
||||
}
|
||||
//
|
||||
// See if we've exceeded our warning count
|
||||
//
|
||||
if (mMaxWarnings != 0) {
|
||||
if (mWarningCount > mMaxWarnings) {
|
||||
PrintLimitExceeded ();
|
||||
return ;
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
mWarningCount++;
|
||||
va_start (List, MsgFmt);
|
||||
PrintMessage ("warning", FileName, LineNumber, MessageCode, Text, MsgFmt, List);
|
||||
va_end (List);
|
||||
//
|
||||
// Set status accordingly
|
||||
//
|
||||
if (mStatus < STATUS_WARNING) {
|
||||
mStatus = STATUS_WARNING;
|
||||
}
|
||||
}
|
||||
|
||||
void
|
||||
DebugMsg (
|
||||
CHAR8 *FileName,
|
||||
UINT32 LineNumber,
|
||||
UINT32 MsgMask,
|
||||
CHAR8 *Text,
|
||||
CHAR8 *MsgFmt,
|
||||
...
|
||||
)
|
||||
/*++
|
||||
|
||||
Routine Description:
|
||||
Print a warning message.
|
||||
|
||||
Arguments:
|
||||
FileName - typically the name of the utility printing the debug message, but
|
||||
can be the name of a file being parsed.
|
||||
|
||||
LineNumber - the line number in FileName (parsers)
|
||||
|
||||
MsgMask - an application-specific bitmask that, in combination with mDebugMsgMask,
|
||||
determines if the debug message gets printed.
|
||||
|
||||
Text - the text in question (parsers)
|
||||
|
||||
MsgFmt - the format string for the debug message. Can contain formatting
|
||||
controls for use with varargs.
|
||||
|
||||
Returns:
|
||||
None.
|
||||
|
||||
--*/
|
||||
{
|
||||
va_list List;
|
||||
//
|
||||
// If the debug mask is not applicable, then do nothing.
|
||||
//
|
||||
if ((MsgMask != 0) && ((mDebugMsgMask & MsgMask) == 0)) {
|
||||
return ;
|
||||
}
|
||||
|
||||
va_start (List, MsgFmt);
|
||||
PrintMessage ("debug", FileName, LineNumber, 0, Text, MsgFmt, List);
|
||||
va_end (List);
|
||||
}
|
||||
|
||||
static
|
||||
void
|
||||
PrintMessage (
|
||||
CHAR8 *Type,
|
||||
CHAR8 *FileName,
|
||||
UINT32 LineNumber,
|
||||
UINT32 MessageCode,
|
||||
CHAR8 *Text,
|
||||
CHAR8 *MsgFmt,
|
||||
va_list List
|
||||
)
|
||||
/*++
|
||||
|
||||
Routine Description:
|
||||
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.
|
||||
|
||||
Arguments:
|
||||
Type - "warning" or "error" string to insert into the message to be
|
||||
printed. The first character of this string (converted to uppercase)
|
||||
is used to preceed the MessageCode value in the output string.
|
||||
|
||||
FileName - name of the file where the warning was detected, or the name
|
||||
of the application that detected the warning
|
||||
|
||||
LineNumber - the line number where the warning was detected (parsers).
|
||||
0 should be specified if the utility is not a parser.
|
||||
|
||||
MessageCode - an application-specific warning code that can be referenced in
|
||||
other documentation.
|
||||
|
||||
Text - part of the message to print
|
||||
|
||||
MsgFmt - the format string for the message. Can contain formatting
|
||||
controls for use with varargs.
|
||||
List - the variable list.
|
||||
|
||||
Returns:
|
||||
None.
|
||||
|
||||
Notes:
|
||||
If FileName == NULL then this utility will use the string passed into SetUtilityName().
|
||||
|
||||
LineNumber is only used if the caller is a parser, in which case FileName refers to the
|
||||
file being parsed.
|
||||
|
||||
Text and MsgFmt are both optional, though it would be of little use calling this function with
|
||||
them both NULL.
|
||||
|
||||
Output will typically be of the form:
|
||||
<FileName>(<LineNumber>) : <Type> <Type[0]><MessageCode>: <Text> : <MsgFmt>
|
||||
|
||||
Parser (LineNumber != 0)
|
||||
VfrCompile.cpp(330) : error E2660: AddVfrDataStructField : function does not take 2 parameters
|
||||
Generic utility (LineNumber == 0)
|
||||
UtilityName : error E1234 : Text string : MsgFmt string and args
|
||||
|
||||
--*/
|
||||
{
|
||||
CHAR8 Line[MAX_LINE_LEN];
|
||||
CHAR8 Line2[MAX_LINE_LEN];
|
||||
CHAR8 *Cptr;
|
||||
//
|
||||
// If given a filename, then add it (and the line number) to the string.
|
||||
// If there's no filename, then use the program name if provided.
|
||||
//
|
||||
if (FileName != NULL) {
|
||||
Cptr = FileName;
|
||||
} else if (mUtilityName[0] != 0) {
|
||||
Cptr = mUtilityName;
|
||||
} else {
|
||||
Cptr = "Unknown utility";
|
||||
}
|
||||
|
||||
strcpy (Line, Cptr);
|
||||
if (LineNumber != 0) {
|
||||
sprintf (Line2, "(%d)", LineNumber);
|
||||
strcat (Line, Line2);
|
||||
}
|
||||
//
|
||||
// Have to print an error code or Visual Studio won't find the
|
||||
// message for you. It has to be decimal digits too.
|
||||
//
|
||||
sprintf (Line2, " : %s %c%04d", Type, toupper (Type[0]), MessageCode);
|
||||
strcat (Line, Line2);
|
||||
fprintf (stdout, "%s", Line);
|
||||
//
|
||||
// If offending text was provided, then print it
|
||||
//
|
||||
if (Text != NULL) {
|
||||
fprintf (stdout, ": %s ", Text);
|
||||
}
|
||||
//
|
||||
// Print formatted message if provided
|
||||
//
|
||||
if (MsgFmt != NULL) {
|
||||
vsprintf (Line2, MsgFmt, List);
|
||||
fprintf (stdout, ": %s", Line2);
|
||||
}
|
||||
|
||||
fprintf (stdout, "\n");
|
||||
}
|
||||
|
||||
void
|
||||
ParserSetPosition (
|
||||
CHAR8 *SourceFileName,
|
||||
UINT32 LineNum
|
||||
)
|
||||
/*++
|
||||
|
||||
Routine Description:
|
||||
Set the position in a file being parsed. This can be used to
|
||||
print error messages deeper down in a parser.
|
||||
|
||||
Arguments:
|
||||
SourceFileName - name of the source file being parsed
|
||||
LineNum - line number of the source file being parsed
|
||||
|
||||
Returns:
|
||||
NA
|
||||
|
||||
--*/
|
||||
{
|
||||
mSourceFileName = SourceFileName;
|
||||
mSourceFileLineNum = LineNum;
|
||||
}
|
||||
|
||||
void
|
||||
SetUtilityName (
|
||||
CHAR8 *UtilityName
|
||||
)
|
||||
/*++
|
||||
|
||||
Routine Description:
|
||||
All printed error/warning/debug messages follow the same format, and
|
||||
typically will print a filename or utility name followed by the error
|
||||
text. However if a filename is not passed to the print routines, then
|
||||
they'll print the utility name if you call this function early in your
|
||||
app to set the utility name.
|
||||
|
||||
Arguments:
|
||||
UtilityName - name of the utility, which will be printed with all
|
||||
error/warning/debug messags.
|
||||
|
||||
Returns:
|
||||
NA
|
||||
|
||||
--*/
|
||||
{
|
||||
//
|
||||
// Save the name of the utility in our local variable. Make sure its
|
||||
// length does not exceed our buffer.
|
||||
//
|
||||
if (UtilityName != NULL) {
|
||||
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;
|
||||
return ;
|
||||
} else {
|
||||
strcpy (mUtilityName, UtilityName);
|
||||
}
|
||||
} else {
|
||||
Error (NULL, 0, 0, "application error", "SetUtilityName() called with NULL utility name");
|
||||
}
|
||||
}
|
||||
|
||||
STATUS
|
||||
GetUtilityStatus (
|
||||
VOID
|
||||
)
|
||||
/*++
|
||||
|
||||
Routine Description:
|
||||
When you call Error() or Warning(), this module keeps track of it and
|
||||
sets a local mStatus to STATUS_ERROR or STATUS_WARNING. When the utility
|
||||
exits, it can call this function to get the status and use it as a return
|
||||
value.
|
||||
|
||||
Arguments:
|
||||
None.
|
||||
|
||||
Returns:
|
||||
Worst-case status reported, as defined by which print function was called.
|
||||
|
||||
--*/
|
||||
{
|
||||
return mStatus;
|
||||
}
|
||||
|
||||
void
|
||||
SetDebugMsgMask (
|
||||
UINT32 DebugMask
|
||||
)
|
||||
/*++
|
||||
|
||||
Routine Description:
|
||||
Set the debug printing mask. This is used by the DebugMsg() function
|
||||
to determine when/if a debug message should be printed.
|
||||
|
||||
Arguments:
|
||||
DebugMask - bitmask, specific to the calling application
|
||||
|
||||
Returns:
|
||||
NA
|
||||
|
||||
--*/
|
||||
{
|
||||
mDebugMsgMask = DebugMask;
|
||||
}
|
||||
|
||||
void
|
||||
SetPrintLimits (
|
||||
UINT32 MaxErrors,
|
||||
UINT32 MaxWarnings,
|
||||
UINT32 MaxWarningsPlusErrors
|
||||
)
|
||||
/*++
|
||||
|
||||
Routine Description:
|
||||
Set the limits of how many errors, warnings, and errors+warnings
|
||||
we will print.
|
||||
|
||||
Arguments:
|
||||
MaxErrors - maximum number of error messages to print
|
||||
MaxWarnings - maximum number of warning messages to print
|
||||
MaxWarningsPlusErrors
|
||||
- maximum number of errors+warnings to print
|
||||
|
||||
Returns:
|
||||
NA
|
||||
|
||||
--*/
|
||||
{
|
||||
mMaxErrors = MaxErrors;
|
||||
mMaxWarnings = MaxWarnings;
|
||||
mMaxWarningsPlusErrors = MaxWarningsPlusErrors;
|
||||
mPrintLimitsSet = 1;
|
||||
}
|
||||
|
||||
static
|
||||
void
|
||||
PrintLimitExceeded (
|
||||
VOID
|
||||
)
|
||||
{
|
||||
static INT8 mPrintLimitExceeded = 0;
|
||||
//
|
||||
// If we've already printed the message, do nothing. Otherwise
|
||||
// temporarily increase our print limits so we can pass one
|
||||
// more message through.
|
||||
//
|
||||
if (mPrintLimitExceeded == 0) {
|
||||
mPrintLimitExceeded++;
|
||||
mMaxErrors++;
|
||||
mMaxWarnings++;
|
||||
mMaxWarningsPlusErrors++;
|
||||
Error (NULL, 0, 0, "error/warning print limit exceeded", NULL);
|
||||
mMaxErrors--;
|
||||
mMaxWarnings--;
|
||||
mMaxWarningsPlusErrors--;
|
||||
}
|
||||
}
|
||||
|
||||
#if 0
|
||||
void
|
||||
TestUtilityMessages (
|
||||
VOID
|
||||
)
|
||||
{
|
||||
char *ArgStr = "ArgString";
|
||||
int ArgInt;
|
||||
|
||||
ArgInt = 0x12345678;
|
||||
//
|
||||
// Test without setting utility name
|
||||
//
|
||||
fprintf (stdout, "* Testing without setting utility name\n");
|
||||
fprintf (stdout, "** Test debug message not printed\n");
|
||||
DebugMsg (NULL, 0, 0x00000001, NULL, NULL);
|
||||
fprintf (stdout, "** Test warning with two strings and two args\n");
|
||||
Warning (NULL, 0, 1234, "Text1", "Text2 %s 0x%X", ArgStr, ArgInt);
|
||||
fprintf (stdout, "** Test error with two strings and two args\n");
|
||||
Warning (NULL, 0, 1234, "Text1", "Text2 %s 0x%X", ArgStr, ArgInt);
|
||||
fprintf (stdout, "** Test parser warning with nothing\n");
|
||||
ParserWarning (0, NULL, NULL);
|
||||
fprintf (stdout, "** Test parser error with nothing\n");
|
||||
ParserError (0, NULL, NULL);
|
||||
//
|
||||
// Test with utility name set now
|
||||
//
|
||||
fprintf (stdout, "** Testingin with utility name set\n");
|
||||
SetUtilityName ("MyUtilityName");
|
||||
//
|
||||
// Test debug prints
|
||||
//
|
||||
SetDebugMsgMask (2);
|
||||
fprintf (stdout, "** Test debug message with one string\n");
|
||||
DebugMsg (NULL, 0, 0x00000002, "Text1", NULL);
|
||||
fprintf (stdout, "** Test debug message with one string\n");
|
||||
DebugMsg (NULL, 0, 0x00000002, NULL, "Text2");
|
||||
fprintf (stdout, "** Test debug message with two strings\n");
|
||||
DebugMsg (NULL, 0, 0x00000002, "Text1", "Text2");
|
||||
fprintf (stdout, "** Test debug message with two strings and two args\n");
|
||||
DebugMsg (NULL, 0, 0x00000002, "Text1", "Text2 %s 0x%X", ArgStr, ArgInt);
|
||||
//
|
||||
// Test warning prints
|
||||
//
|
||||
fprintf (stdout, "** Test warning with no strings\n");
|
||||
Warning (NULL, 0, 1234, NULL, NULL);
|
||||
fprintf (stdout, "** Test warning with one string\n");
|
||||
Warning (NULL, 0, 1234, "Text1", NULL);
|
||||
fprintf (stdout, "** Test warning with one string\n");
|
||||
Warning (NULL, 0, 1234, NULL, "Text2");
|
||||
fprintf (stdout, "** Test warning with two strings and two args\n");
|
||||
Warning (NULL, 0, 1234, "Text1", "Text2 %s 0x%X", ArgStr, ArgInt);
|
||||
//
|
||||
// Test error prints
|
||||
//
|
||||
fprintf (stdout, "** Test error with no strings\n");
|
||||
Error (NULL, 0, 1234, NULL, NULL);
|
||||
fprintf (stdout, "** Test error with one string\n");
|
||||
Error (NULL, 0, 1234, "Text1", NULL);
|
||||
fprintf (stdout, "** Test error with one string\n");
|
||||
Error (NULL, 0, 1234, NULL, "Text2");
|
||||
fprintf (stdout, "** Test error with two strings and two args\n");
|
||||
Error (NULL, 0, 1234, "Text1", "Text2 %s 0x%X", ArgStr, ArgInt);
|
||||
//
|
||||
// Test parser prints
|
||||
//
|
||||
fprintf (stdout, "** Test parser errors\n");
|
||||
ParserSetPosition (__FILE__, __LINE__ + 1);
|
||||
ParserError (1234, NULL, NULL);
|
||||
ParserSetPosition (__FILE__, __LINE__ + 1);
|
||||
ParserError (1234, "Text1", NULL);
|
||||
ParserSetPosition (__FILE__, __LINE__ + 1);
|
||||
ParserError (1234, NULL, "Text2");
|
||||
ParserSetPosition (__FILE__, __LINE__ + 1);
|
||||
ParserError (1234, "Text1", "Text2");
|
||||
ParserSetPosition (__FILE__, __LINE__ + 1);
|
||||
ParserError (1234, "Text1", "Text2 %s 0x%X", ArgStr, ArgInt);
|
||||
|
||||
fprintf (stdout, "** Test parser warnings\n");
|
||||
ParserSetPosition (__FILE__, __LINE__ + 1);
|
||||
ParserWarning (4321, NULL, NULL);
|
||||
ParserSetPosition (__FILE__, __LINE__ + 1);
|
||||
ParserWarning (4321, "Text1", NULL);
|
||||
ParserSetPosition (__FILE__, __LINE__ + 1);
|
||||
ParserWarning (4321, NULL, "Text2");
|
||||
ParserSetPosition (__FILE__, __LINE__ + 1);
|
||||
ParserWarning (4321, "Text1", "Text2");
|
||||
ParserSetPosition (__FILE__, __LINE__ + 1);
|
||||
ParserWarning (4321, "Text1", "Text2 %s 0x%X", ArgStr, ArgInt);
|
||||
}
|
||||
#endif
|
||||
137
Tools/CodeTools/Source/Common/EfiUtilityMsgs.h
Normal file
137
Tools/CodeTools/Source/Common/EfiUtilityMsgs.h
Normal file
@ -0,0 +1,137 @@
|
||||
/*++
|
||||
|
||||
Copyright (c) 2004, Intel Corporation
|
||||
All rights reserved. This program and the accompanying materials
|
||||
are licensed and made available under the terms and conditions of the BSD License
|
||||
which accompanies this distribution. The full text of the license may be found at
|
||||
http://opensource.org/licenses/bsd-license.php
|
||||
|
||||
THE PROGRAM IS DISTRIBUTED UNDER THE BSD LICENSE ON AN "AS IS" BASIS,
|
||||
WITHOUT WARRANTIES OR REPRESENTATIONS OF ANY KIND, EITHER EXPRESS OR IMPLIED.
|
||||
|
||||
Module Name:
|
||||
|
||||
EfiUtilityMsgs.h
|
||||
|
||||
Abstract:
|
||||
|
||||
Defines and prototypes for common EFI utility error and debug messages.
|
||||
|
||||
--*/
|
||||
|
||||
#ifndef _EFI_UTILITY_MSGS_H_
|
||||
#define _EFI_UTILITY_MSGS_H_
|
||||
|
||||
#include <Common/UefiBaseTypes.h>
|
||||
|
||||
//
|
||||
// Status codes returned by EFI utility programs and functions
|
||||
//
|
||||
#define STATUS_SUCCESS 0
|
||||
#define STATUS_WARNING 1
|
||||
#define STATUS_ERROR 2
|
||||
#define VOID void
|
||||
|
||||
typedef int STATUS;
|
||||
|
||||
#ifdef __cplusplus
|
||||
extern "C" {
|
||||
#endif
|
||||
//
|
||||
// When we call Error() or Warning(), the module keeps track of the worst
|
||||
// case reported. GetUtilityStatus() will get the worst-case results, which
|
||||
// can be used as the return value from the app.
|
||||
//
|
||||
STATUS
|
||||
GetUtilityStatus (
|
||||
void
|
||||
);
|
||||
|
||||
//
|
||||
// If someone prints an error message and didn't specify a source file name,
|
||||
// then we print the utility name instead. However they must tell us the
|
||||
// utility name early on via this function.
|
||||
//
|
||||
void
|
||||
SetUtilityName (
|
||||
CHAR8 *ProgramName
|
||||
)
|
||||
;
|
||||
|
||||
void
|
||||
Error (
|
||||
CHAR8 *FileName,
|
||||
UINT32 LineNumber,
|
||||
UINT32 ErrorCode,
|
||||
CHAR8 *OffendingText,
|
||||
CHAR8 *MsgFmt,
|
||||
...
|
||||
)
|
||||
;
|
||||
|
||||
void
|
||||
Warning (
|
||||
CHAR8 *FileName,
|
||||
UINT32 LineNumber,
|
||||
UINT32 ErrorCode,
|
||||
CHAR8 *OffendingText,
|
||||
CHAR8 *MsgFmt,
|
||||
...
|
||||
)
|
||||
;
|
||||
|
||||
void
|
||||
DebugMsg (
|
||||
CHAR8 *FileName,
|
||||
UINT32 LineNumber,
|
||||
UINT32 MsgLevel,
|
||||
CHAR8 *OffendingText,
|
||||
CHAR8 *MsgFmt,
|
||||
...
|
||||
)
|
||||
;
|
||||
|
||||
void
|
||||
SetDebugMsgMask (
|
||||
UINT32 MsgMask
|
||||
)
|
||||
;
|
||||
|
||||
void
|
||||
ParserSetPosition (
|
||||
CHAR8 *SourceFileName,
|
||||
UINT32 LineNum
|
||||
)
|
||||
;
|
||||
|
||||
void
|
||||
ParserError (
|
||||
UINT32 ErrorCode,
|
||||
CHAR8 *OffendingText,
|
||||
CHAR8 *MsgFmt,
|
||||
...
|
||||
)
|
||||
;
|
||||
|
||||
void
|
||||
ParserWarning (
|
||||
UINT32 ErrorCode,
|
||||
CHAR8 *OffendingText,
|
||||
CHAR8 *MsgFmt,
|
||||
...
|
||||
)
|
||||
;
|
||||
|
||||
void
|
||||
SetPrintLimits (
|
||||
UINT32 NumErrors,
|
||||
UINT32 NumWarnings,
|
||||
UINT32 NumWarningsPlusErrors
|
||||
)
|
||||
;
|
||||
|
||||
#ifdef __cplusplus
|
||||
}
|
||||
#endif
|
||||
|
||||
#endif // #ifndef _EFI_UTILITY_MSGS_H_
|
||||
780
Tools/CodeTools/Source/Common/FvLib.c
Normal file
780
Tools/CodeTools/Source/Common/FvLib.c
Normal file
@ -0,0 +1,780 @@
|
||||
/*++
|
||||
|
||||
Copyright (c) 2004, Intel Corporation
|
||||
All rights reserved. This program and the accompanying materials
|
||||
are licensed and made available under the terms and conditions of the BSD License
|
||||
which accompanies this distribution. The full text of the license may be found at
|
||||
http://opensource.org/licenses/bsd-license.php
|
||||
|
||||
THE PROGRAM IS DISTRIBUTED UNDER THE BSD LICENSE ON AN "AS IS" BASIS,
|
||||
WITHOUT WARRANTIES OR REPRESENTATIONS OF ANY KIND, EITHER EXPRESS OR IMPLIED.
|
||||
|
||||
Module Name:
|
||||
|
||||
FvLib.c
|
||||
|
||||
Abstract:
|
||||
|
||||
These functions assist in parsing and manipulating a Firmware Volume.
|
||||
|
||||
--*/
|
||||
|
||||
//
|
||||
// Include files
|
||||
//
|
||||
#include "FvLib.h"
|
||||
#include "CommonLib.h"
|
||||
#include "EfiUtilityMsgs.h"
|
||||
|
||||
//
|
||||
// Module global variables
|
||||
//
|
||||
EFI_FIRMWARE_VOLUME_HEADER *mFvHeader = NULL;
|
||||
UINT32 mFvLength = 0;
|
||||
|
||||
//
|
||||
// External function implementations
|
||||
//
|
||||
EFI_STATUS
|
||||
InitializeFvLib (
|
||||
IN VOID *Fv,
|
||||
IN UINT32 FvLength
|
||||
)
|
||||
/*++
|
||||
|
||||
Routine Description:
|
||||
|
||||
This initializes the FV lib with a pointer to the FV and length. It does not
|
||||
verify the FV in any way.
|
||||
|
||||
Arguments:
|
||||
|
||||
Fv Buffer containing the FV.
|
||||
FvLength Length of the FV
|
||||
|
||||
Returns:
|
||||
|
||||
EFI_SUCCESS Function Completed successfully.
|
||||
EFI_INVALID_PARAMETER A required parameter was NULL.
|
||||
|
||||
--*/
|
||||
{
|
||||
//
|
||||
// Verify input arguments
|
||||
//
|
||||
if (Fv == NULL) {
|
||||
return EFI_INVALID_PARAMETER;
|
||||
}
|
||||
|
||||
mFvHeader = (EFI_FIRMWARE_VOLUME_HEADER *) Fv;
|
||||
mFvLength = FvLength;
|
||||
|
||||
return EFI_SUCCESS;
|
||||
}
|
||||
|
||||
EFI_STATUS
|
||||
GetFvHeader (
|
||||
OUT EFI_FIRMWARE_VOLUME_HEADER **FvHeader,
|
||||
OUT UINT32 *FvLength
|
||||
)
|
||||
/*++
|
||||
|
||||
Routine Description:
|
||||
|
||||
This function returns a pointer to the current FV and the size.
|
||||
|
||||
Arguments:
|
||||
|
||||
FvHeader Pointer to the FV buffer.
|
||||
FvLength Length of the FV
|
||||
|
||||
Returns:
|
||||
|
||||
EFI_SUCCESS Function Completed successfully.
|
||||
EFI_INVALID_PARAMETER A required parameter was NULL.
|
||||
EFI_ABORTED The library needs to be initialized.
|
||||
|
||||
--*/
|
||||
{
|
||||
//
|
||||
// Verify library has been initialized.
|
||||
//
|
||||
if (mFvHeader == NULL || mFvLength == 0) {
|
||||
return EFI_ABORTED;
|
||||
}
|
||||
//
|
||||
// Verify input arguments
|
||||
//
|
||||
if (FvHeader == NULL) {
|
||||
return EFI_INVALID_PARAMETER;
|
||||
}
|
||||
|
||||
*FvHeader = mFvHeader;
|
||||
return EFI_SUCCESS;
|
||||
}
|
||||
|
||||
EFI_STATUS
|
||||
GetNextFile (
|
||||
IN EFI_FFS_FILE_HEADER *CurrentFile,
|
||||
OUT EFI_FFS_FILE_HEADER **NextFile
|
||||
)
|
||||
/*++
|
||||
|
||||
Routine Description:
|
||||
|
||||
This function returns the next file. If the current file is NULL, it returns
|
||||
the first file in the FV. If the function returns EFI_SUCCESS and the file
|
||||
pointer is NULL, then there are no more files in the FV.
|
||||
|
||||
Arguments:
|
||||
|
||||
CurrentFile Pointer to the current file, must be within the current FV.
|
||||
NextFile Pointer to the next file in the FV.
|
||||
|
||||
Returns:
|
||||
|
||||
EFI_SUCCESS Function completed successfully.
|
||||
EFI_INVALID_PARAMETER A required parameter was NULL or is out of range.
|
||||
EFI_ABORTED The library needs to be initialized.
|
||||
|
||||
--*/
|
||||
{
|
||||
EFI_STATUS Status;
|
||||
|
||||
//
|
||||
// Verify library has been initialized.
|
||||
//
|
||||
if (mFvHeader == NULL || mFvLength == 0) {
|
||||
return EFI_ABORTED;
|
||||
}
|
||||
//
|
||||
// Verify input arguments
|
||||
//
|
||||
if (NextFile == NULL) {
|
||||
return EFI_INVALID_PARAMETER;
|
||||
}
|
||||
//
|
||||
// Verify FV header
|
||||
//
|
||||
Status = VerifyFv (mFvHeader);
|
||||
if (EFI_ERROR (Status)) {
|
||||
return EFI_ABORTED;
|
||||
}
|
||||
//
|
||||
// Get first file
|
||||
//
|
||||
if (CurrentFile == NULL) {
|
||||
CurrentFile = (EFI_FFS_FILE_HEADER *) ((UINTN) mFvHeader + mFvHeader->HeaderLength);
|
||||
|
||||
//
|
||||
// Verify file is valid
|
||||
//
|
||||
Status = VerifyFfsFile (CurrentFile);
|
||||
if (EFI_ERROR (Status)) {
|
||||
//
|
||||
// no files in this FV
|
||||
//
|
||||
*NextFile = NULL;
|
||||
return EFI_SUCCESS;
|
||||
} else {
|
||||
//
|
||||
// Verify file is in this FV.
|
||||
//
|
||||
if ((UINTN) CurrentFile >= (UINTN) mFvHeader + mFvLength - sizeof (EFI_FFS_FILE_HEADER)) {
|
||||
*NextFile = NULL;
|
||||
return EFI_SUCCESS;
|
||||
}
|
||||
|
||||
*NextFile = CurrentFile;
|
||||
return EFI_SUCCESS;
|
||||
}
|
||||
}
|
||||
//
|
||||
// Verify current file is in range
|
||||
//
|
||||
if (((UINTN) CurrentFile < (UINTN) mFvHeader + sizeof (EFI_FIRMWARE_VOLUME_HEADER)) ||
|
||||
((UINTN) CurrentFile >= (UINTN) mFvHeader + mFvLength - sizeof (EFI_FIRMWARE_VOLUME_HEADER))
|
||||
) {
|
||||
return EFI_INVALID_PARAMETER;
|
||||
}
|
||||
//
|
||||
// Get next file, compensate for 8 byte alignment if necessary.
|
||||
//
|
||||
*NextFile = (EFI_FFS_FILE_HEADER *) (((UINTN) CurrentFile + GetLength (CurrentFile->Size) + 0x07) & (-1 << 3));
|
||||
|
||||
//
|
||||
// Verify file is in this FV.
|
||||
//
|
||||
if ((UINTN) *NextFile >= (UINTN) mFvHeader + mFvLength - sizeof (EFI_FFS_FILE_HEADER)) {
|
||||
*NextFile = NULL;
|
||||
return EFI_SUCCESS;
|
||||
}
|
||||
//
|
||||
// Verify file is valid
|
||||
//
|
||||
Status = VerifyFfsFile (*NextFile);
|
||||
if (EFI_ERROR (Status)) {
|
||||
//
|
||||
// no more files in this FV
|
||||
//
|
||||
*NextFile = NULL;
|
||||
return EFI_SUCCESS;
|
||||
}
|
||||
|
||||
return EFI_SUCCESS;
|
||||
}
|
||||
|
||||
EFI_STATUS
|
||||
GetFileByName (
|
||||
IN EFI_GUID *FileName,
|
||||
OUT EFI_FFS_FILE_HEADER **File
|
||||
)
|
||||
/*++
|
||||
|
||||
Routine Description:
|
||||
|
||||
Find a file by name. The function will return NULL if the file is not found.
|
||||
|
||||
Arguments:
|
||||
|
||||
FileName The GUID file name of the file to search for.
|
||||
File Return pointer. In the case of an error, contents are undefined.
|
||||
|
||||
Returns:
|
||||
|
||||
EFI_SUCCESS The function completed successfully.
|
||||
EFI_ABORTED An error was encountered.
|
||||
EFI_INVALID_PARAMETER One of the parameters was NULL.
|
||||
|
||||
--*/
|
||||
{
|
||||
EFI_FFS_FILE_HEADER *CurrentFile;
|
||||
EFI_STATUS Status;
|
||||
|
||||
//
|
||||
// Verify library has been initialized.
|
||||
//
|
||||
if (mFvHeader == NULL || mFvLength == 0) {
|
||||
return EFI_ABORTED;
|
||||
}
|
||||
//
|
||||
// Verify input parameters
|
||||
//
|
||||
if (FileName == NULL || File == NULL) {
|
||||
return EFI_INVALID_PARAMETER;
|
||||
}
|
||||
//
|
||||
// Verify FV header
|
||||
//
|
||||
Status = VerifyFv (mFvHeader);
|
||||
if (EFI_ERROR (Status)) {
|
||||
return EFI_ABORTED;
|
||||
}
|
||||
//
|
||||
// Get the first file
|
||||
//
|
||||
Status = GetNextFile (NULL, &CurrentFile);
|
||||
if (EFI_ERROR (Status)) {
|
||||
Error (NULL, 0, 0, "error parsing the FV", NULL);
|
||||
return EFI_ABORTED;
|
||||
}
|
||||
//
|
||||
// Loop as long as we have a valid file
|
||||
//
|
||||
while (CurrentFile) {
|
||||
if (!CompareGuid (&CurrentFile->Name, FileName)) {
|
||||
*File = CurrentFile;
|
||||
return EFI_SUCCESS;
|
||||
}
|
||||
|
||||
Status = GetNextFile (CurrentFile, &CurrentFile);
|
||||
if (EFI_ERROR (Status)) {
|
||||
Error (NULL, 0, 0, "error parsing the FV", NULL);
|
||||
return EFI_ABORTED;
|
||||
}
|
||||
}
|
||||
//
|
||||
// File not found in this FV.
|
||||
//
|
||||
*File = NULL;
|
||||
return EFI_SUCCESS;
|
||||
}
|
||||
|
||||
EFI_STATUS
|
||||
GetFileByType (
|
||||
IN EFI_FV_FILETYPE FileType,
|
||||
IN UINTN Instance,
|
||||
OUT EFI_FFS_FILE_HEADER **File
|
||||
)
|
||||
/*++
|
||||
|
||||
Routine Description:
|
||||
|
||||
Find a file by type and instance. An instance of 1 is the first instance.
|
||||
The function will return NULL if a matching file cannot be found.
|
||||
File type EFI_FV_FILETYPE_ALL means any file type is valid.
|
||||
|
||||
Arguments:
|
||||
|
||||
FileType Type of file to search for.
|
||||
Instance Instace of the file type to return.
|
||||
File Return pointer. In the case of an error, contents are undefined.
|
||||
|
||||
Returns:
|
||||
|
||||
EFI_SUCCESS The function completed successfully.
|
||||
EFI_ABORTED An error was encountered.
|
||||
EFI_INVALID_PARAMETER One of the parameters was NULL.
|
||||
|
||||
--*/
|
||||
{
|
||||
EFI_FFS_FILE_HEADER *CurrentFile;
|
||||
EFI_STATUS Status;
|
||||
UINTN FileCount;
|
||||
|
||||
//
|
||||
// Verify library has been initialized.
|
||||
//
|
||||
if (mFvHeader == NULL || mFvLength == 0) {
|
||||
return EFI_ABORTED;
|
||||
}
|
||||
//
|
||||
// Verify input parameters
|
||||
//
|
||||
if (File == NULL) {
|
||||
return EFI_INVALID_PARAMETER;
|
||||
}
|
||||
//
|
||||
// Verify FV header
|
||||
//
|
||||
Status = VerifyFv (mFvHeader);
|
||||
if (EFI_ERROR (Status)) {
|
||||
return EFI_ABORTED;
|
||||
}
|
||||
//
|
||||
// Initialize the number of matching files found.
|
||||
//
|
||||
FileCount = 0;
|
||||
|
||||
//
|
||||
// Get the first file
|
||||
//
|
||||
Status = GetNextFile (NULL, &CurrentFile);
|
||||
if (EFI_ERROR (Status)) {
|
||||
Error (NULL, 0, 0, "error parsing FV", NULL);
|
||||
return EFI_ABORTED;
|
||||
}
|
||||
//
|
||||
// Loop as long as we have a valid file
|
||||
//
|
||||
while (CurrentFile) {
|
||||
if (FileType == EFI_FV_FILETYPE_ALL || CurrentFile->Type == FileType) {
|
||||
FileCount++;
|
||||
}
|
||||
|
||||
if (FileCount == Instance) {
|
||||
*File = CurrentFile;
|
||||
return EFI_SUCCESS;
|
||||
}
|
||||
|
||||
Status = GetNextFile (CurrentFile, &CurrentFile);
|
||||
if (EFI_ERROR (Status)) {
|
||||
Error (NULL, 0, 0, "error parsing the FV", NULL);
|
||||
return EFI_ABORTED;
|
||||
}
|
||||
}
|
||||
|
||||
*File = NULL;
|
||||
return EFI_SUCCESS;
|
||||
}
|
||||
|
||||
EFI_STATUS
|
||||
GetSectionByType (
|
||||
IN EFI_FFS_FILE_HEADER *File,
|
||||
IN EFI_SECTION_TYPE SectionType,
|
||||
IN UINTN Instance,
|
||||
OUT EFI_FILE_SECTION_POINTER *Section
|
||||
)
|
||||
/*++
|
||||
|
||||
Routine Description:
|
||||
|
||||
Find a section in a file by type and instance. An instance of 1 is the first
|
||||
instance. The function will return NULL if a matching section cannot be found.
|
||||
The function will not handle encapsulating sections.
|
||||
|
||||
Arguments:
|
||||
|
||||
File The file to search.
|
||||
SectionType Type of file to search for.
|
||||
Instance Instace of the section to return.
|
||||
Section Return pointer. In the case of an error, contents are undefined.
|
||||
|
||||
Returns:
|
||||
|
||||
EFI_SUCCESS The function completed successfully.
|
||||
EFI_ABORTED An error was encountered.
|
||||
EFI_INVALID_PARAMETER One of the parameters was NULL.
|
||||
EFI_NOT_FOUND No found.
|
||||
--*/
|
||||
{
|
||||
EFI_FILE_SECTION_POINTER CurrentSection;
|
||||
EFI_STATUS Status;
|
||||
UINTN SectionCount;
|
||||
|
||||
//
|
||||
// Verify input parameters
|
||||
//
|
||||
if (File == NULL || Instance == 0) {
|
||||
return EFI_INVALID_PARAMETER;
|
||||
}
|
||||
//
|
||||
// Verify FFS header
|
||||
//
|
||||
Status = VerifyFfsFile (File);
|
||||
if (EFI_ERROR (Status)) {
|
||||
Error (NULL, 0, 0, "invalid FFS file", NULL);
|
||||
return EFI_ABORTED;
|
||||
}
|
||||
//
|
||||
// Initialize the number of matching sections found.
|
||||
//
|
||||
SectionCount = 0;
|
||||
|
||||
//
|
||||
// Get the first section
|
||||
//
|
||||
CurrentSection.CommonHeader = (EFI_COMMON_SECTION_HEADER *) ((UINTN) File + sizeof (EFI_FFS_FILE_HEADER));
|
||||
|
||||
//
|
||||
// Loop as long as we have a valid file
|
||||
//
|
||||
while ((UINTN) CurrentSection.CommonHeader < (UINTN) File + GetLength (File->Size)) {
|
||||
if (CurrentSection.CommonHeader->Type == SectionType) {
|
||||
SectionCount++;
|
||||
}
|
||||
|
||||
if (SectionCount == Instance) {
|
||||
*Section = CurrentSection;
|
||||
return EFI_SUCCESS;
|
||||
}
|
||||
//
|
||||
// Find next section (including compensating for alignment issues.
|
||||
//
|
||||
CurrentSection.CommonHeader = (EFI_COMMON_SECTION_HEADER *) ((((UINTN) CurrentSection.CommonHeader) + GetLength (CurrentSection.CommonHeader->Size) + 0x03) & (-1 << 2));
|
||||
}
|
||||
//
|
||||
// Section not found
|
||||
//
|
||||
(*Section).Code16Section = NULL;
|
||||
return EFI_NOT_FOUND;
|
||||
}
|
||||
//
|
||||
// will not parse compressed sections
|
||||
//
|
||||
EFI_STATUS
|
||||
VerifyFv (
|
||||
IN EFI_FIRMWARE_VOLUME_HEADER *FvHeader
|
||||
)
|
||||
/*++
|
||||
|
||||
Routine Description:
|
||||
|
||||
Verify the current pointer points to a valid FV header.
|
||||
|
||||
Arguments:
|
||||
|
||||
FvHeader Pointer to an alleged FV file.
|
||||
|
||||
Returns:
|
||||
|
||||
EFI_SUCCESS The FV header is valid.
|
||||
EFI_VOLUME_CORRUPTED The FV header is not valid.
|
||||
EFI_INVALID_PARAMETER A required parameter was NULL.
|
||||
EFI_ABORTED Operation aborted.
|
||||
|
||||
--*/
|
||||
{
|
||||
UINT16 Checksum;
|
||||
|
||||
//
|
||||
// Verify input parameters
|
||||
//
|
||||
if (FvHeader == NULL) {
|
||||
return EFI_INVALID_PARAMETER;
|
||||
}
|
||||
|
||||
if (FvHeader->Signature != EFI_FVH_SIGNATURE) {
|
||||
Error (NULL, 0, 0, "invalid FV header signature", NULL);
|
||||
return EFI_VOLUME_CORRUPTED;
|
||||
}
|
||||
//
|
||||
// Verify header checksum
|
||||
//
|
||||
Checksum = CalculateSum16 ((UINT16 *) FvHeader, FvHeader->HeaderLength / sizeof (UINT16));
|
||||
|
||||
if (Checksum != 0) {
|
||||
Error (NULL, 0, 0, "invalid FV header checksum", NULL);
|
||||
return EFI_ABORTED;
|
||||
}
|
||||
|
||||
return EFI_SUCCESS;
|
||||
}
|
||||
|
||||
EFI_STATUS
|
||||
VerifyFfsFile (
|
||||
IN EFI_FFS_FILE_HEADER *FfsHeader
|
||||
)
|
||||
/*++
|
||||
|
||||
Routine Description:
|
||||
|
||||
Verify the current pointer points to a FFS file header.
|
||||
|
||||
Arguments:
|
||||
|
||||
FfsHeader Pointer to an alleged FFS file.
|
||||
|
||||
Returns:
|
||||
|
||||
EFI_SUCCESS The Ffs header is valid.
|
||||
EFI_NOT_FOUND This "file" is the beginning of free space.
|
||||
EFI_VOLUME_CORRUPTED The Ffs header is not valid.
|
||||
EFI_ABORTED The erase polarity is not known.
|
||||
|
||||
--*/
|
||||
{
|
||||
BOOLEAN ErasePolarity;
|
||||
EFI_STATUS Status;
|
||||
EFI_FFS_FILE_HEADER BlankHeader;
|
||||
UINT8 Checksum;
|
||||
UINT32 FileLength;
|
||||
UINT32 OccupiedFileLength;
|
||||
EFI_FFS_FILE_TAIL *Tail;
|
||||
UINT8 SavedChecksum;
|
||||
UINT8 SavedState;
|
||||
UINT8 FileGuidString[80];
|
||||
UINT32 TailSize;
|
||||
//
|
||||
// Verify library has been initialized.
|
||||
//
|
||||
if (mFvHeader == NULL || mFvLength == 0) {
|
||||
return EFI_ABORTED;
|
||||
}
|
||||
//
|
||||
// Verify FV header
|
||||
//
|
||||
Status = VerifyFv (mFvHeader);
|
||||
if (EFI_ERROR (Status)) {
|
||||
return EFI_ABORTED;
|
||||
}
|
||||
//
|
||||
// Get the erase polarity.
|
||||
//
|
||||
Status = GetErasePolarity (&ErasePolarity);
|
||||
if (EFI_ERROR (Status)) {
|
||||
return EFI_ABORTED;
|
||||
}
|
||||
//
|
||||
// Check if we have free space
|
||||
//
|
||||
if (ErasePolarity) {
|
||||
memset (&BlankHeader, -1, sizeof (EFI_FFS_FILE_HEADER));
|
||||
} else {
|
||||
memset (&BlankHeader, 0, sizeof (EFI_FFS_FILE_HEADER));
|
||||
}
|
||||
|
||||
if (memcmp (&BlankHeader, FfsHeader, sizeof (EFI_FFS_FILE_HEADER)) == 0) {
|
||||
return EFI_NOT_FOUND;
|
||||
}
|
||||
//
|
||||
// Convert the GUID to a string so we can at least report which file
|
||||
// if we find an error.
|
||||
//
|
||||
PrintGuidToBuffer (&FfsHeader->Name, FileGuidString, sizeof (FileGuidString), TRUE);
|
||||
if (FfsHeader->Attributes & FFS_ATTRIB_TAIL_PRESENT) {
|
||||
TailSize = sizeof (EFI_FFS_FILE_TAIL);
|
||||
} else {
|
||||
TailSize = 0;
|
||||
}
|
||||
//
|
||||
// Verify file header checksum
|
||||
//
|
||||
SavedState = FfsHeader->State;
|
||||
FfsHeader->State = 0;
|
||||
SavedChecksum = FfsHeader->IntegrityCheck.Checksum.File;
|
||||
FfsHeader->IntegrityCheck.Checksum.File = 0;
|
||||
Checksum = CalculateSum8 ((UINT8 *) FfsHeader, sizeof (EFI_FFS_FILE_HEADER));
|
||||
FfsHeader->State = SavedState;
|
||||
FfsHeader->IntegrityCheck.Checksum.File = SavedChecksum;
|
||||
if (Checksum != 0) {
|
||||
Error (NULL, 0, 0, FileGuidString, "invalid FFS file header checksum");
|
||||
return EFI_ABORTED;
|
||||
}
|
||||
//
|
||||
// Verify file checksum
|
||||
//
|
||||
if (FfsHeader->Attributes & FFS_ATTRIB_CHECKSUM) {
|
||||
//
|
||||
// Verify file data checksum
|
||||
//
|
||||
FileLength = GetLength (FfsHeader->Size);
|
||||
OccupiedFileLength = (FileLength + 0x07) & (-1 << 3);
|
||||
Checksum = CalculateSum8 ((UINT8 *) FfsHeader, FileLength - TailSize);
|
||||
Checksum = (UINT8) (Checksum - FfsHeader->State);
|
||||
if (Checksum != 0) {
|
||||
Error (NULL, 0, 0, FileGuidString, "invalid FFS file checksum");
|
||||
return EFI_ABORTED;
|
||||
}
|
||||
} else {
|
||||
//
|
||||
// File does not have a checksum
|
||||
// Verify contents are 0x5A as spec'd
|
||||
//
|
||||
if (FfsHeader->IntegrityCheck.Checksum.File != FFS_FIXED_CHECKSUM) {
|
||||
Error (NULL, 0, 0, FileGuidString, "invalid fixed FFS file header checksum");
|
||||
return EFI_ABORTED;
|
||||
}
|
||||
}
|
||||
//
|
||||
// Check if the tail is present and verify it if it is.
|
||||
//
|
||||
if (FfsHeader->Attributes & FFS_ATTRIB_TAIL_PRESENT) {
|
||||
//
|
||||
// Verify tail is complement of integrity check field in the header.
|
||||
//
|
||||
Tail = (EFI_FFS_FILE_TAIL *) ((UINTN) FfsHeader + GetLength (FfsHeader->Size) - sizeof (EFI_FFS_FILE_TAIL));
|
||||
if (FfsHeader->IntegrityCheck.TailReference != (EFI_FFS_FILE_TAIL)~(*Tail)) {
|
||||
Error (NULL, 0, 0, FileGuidString, "invalid FFS file tail");
|
||||
return EFI_ABORTED;
|
||||
}
|
||||
}
|
||||
|
||||
return EFI_SUCCESS;
|
||||
}
|
||||
|
||||
UINT32
|
||||
GetLength (
|
||||
UINT8 *ThreeByteLength
|
||||
)
|
||||
/*++
|
||||
|
||||
Routine Description:
|
||||
|
||||
Converts a three byte length value into a UINT32.
|
||||
|
||||
Arguments:
|
||||
|
||||
ThreeByteLength Pointer to the first of the 3 byte length.
|
||||
|
||||
Returns:
|
||||
|
||||
UINT32 Size of the section
|
||||
|
||||
--*/
|
||||
{
|
||||
UINT32 Length;
|
||||
|
||||
if (ThreeByteLength == NULL) {
|
||||
return 0;
|
||||
}
|
||||
|
||||
Length = *((UINT32 *) ThreeByteLength);
|
||||
Length = Length & 0x00FFFFFF;
|
||||
|
||||
return Length;
|
||||
}
|
||||
|
||||
EFI_STATUS
|
||||
GetErasePolarity (
|
||||
OUT BOOLEAN *ErasePolarity
|
||||
)
|
||||
/*++
|
||||
|
||||
Routine Description:
|
||||
|
||||
This function returns with the FV erase polarity. If the erase polarity
|
||||
for a bit is 1, the function return TRUE.
|
||||
|
||||
Arguments:
|
||||
|
||||
ErasePolarity A pointer to the erase polarity.
|
||||
|
||||
Returns:
|
||||
|
||||
EFI_SUCCESS The function completed successfully.
|
||||
EFI_INVALID_PARAMETER One of the input parameters was invalid.
|
||||
EFI_ABORTED Operation aborted.
|
||||
|
||||
--*/
|
||||
{
|
||||
EFI_STATUS Status;
|
||||
|
||||
//
|
||||
// Verify library has been initialized.
|
||||
//
|
||||
if (mFvHeader == NULL || mFvLength == 0) {
|
||||
return EFI_ABORTED;
|
||||
}
|
||||
//
|
||||
// Verify FV header
|
||||
//
|
||||
Status = VerifyFv (mFvHeader);
|
||||
if (EFI_ERROR (Status)) {
|
||||
return EFI_ABORTED;
|
||||
}
|
||||
//
|
||||
// Verify input parameters.
|
||||
//
|
||||
if (ErasePolarity == NULL) {
|
||||
return EFI_INVALID_PARAMETER;
|
||||
}
|
||||
|
||||
if (mFvHeader->Attributes & EFI_FVB_ERASE_POLARITY) {
|
||||
*ErasePolarity = TRUE;
|
||||
} else {
|
||||
*ErasePolarity = FALSE;
|
||||
}
|
||||
|
||||
return EFI_SUCCESS;
|
||||
}
|
||||
|
||||
UINT8
|
||||
GetFileState (
|
||||
IN BOOLEAN ErasePolarity,
|
||||
IN EFI_FFS_FILE_HEADER *FfsHeader
|
||||
)
|
||||
/*++
|
||||
|
||||
Routine Description:
|
||||
|
||||
This function returns a the highest state bit in the FFS that is set.
|
||||
It in no way validate the FFS file.
|
||||
|
||||
Arguments:
|
||||
|
||||
ErasePolarity The erase polarity for the file state bits.
|
||||
FfsHeader Pointer to a FFS file.
|
||||
|
||||
Returns:
|
||||
|
||||
UINT8 The hightest set state of the file.
|
||||
|
||||
--*/
|
||||
{
|
||||
UINT8 FileState;
|
||||
UINT8 HighestBit;
|
||||
|
||||
FileState = FfsHeader->State;
|
||||
|
||||
if (ErasePolarity) {
|
||||
FileState = (UINT8)~FileState;
|
||||
}
|
||||
|
||||
HighestBit = 0x80;
|
||||
while (HighestBit != 0 && (HighestBit & FileState) == 0) {
|
||||
HighestBit >>= 1;
|
||||
}
|
||||
|
||||
return HighestBit;
|
||||
}
|
||||
181
Tools/CodeTools/Source/Common/FvLib.h
Normal file
181
Tools/CodeTools/Source/Common/FvLib.h
Normal file
@ -0,0 +1,181 @@
|
||||
/*++
|
||||
|
||||
Copyright (c) 2004, Intel Corporation
|
||||
All rights reserved. This program and the accompanying materials
|
||||
are licensed and made available under the terms and conditions of the BSD License
|
||||
which accompanies this distribution. The full text of the license may be found at
|
||||
http://opensource.org/licenses/bsd-license.php
|
||||
|
||||
THE PROGRAM IS DISTRIBUTED UNDER THE BSD LICENSE ON AN "AS IS" BASIS,
|
||||
WITHOUT WARRANTIES OR REPRESENTATIONS OF ANY KIND, EITHER EXPRESS OR IMPLIED.
|
||||
|
||||
Module Name:
|
||||
|
||||
FvLib.h
|
||||
|
||||
Abstract:
|
||||
|
||||
These functions assist in parsing and manipulating a Firmware Volume.
|
||||
|
||||
--*/
|
||||
|
||||
#ifndef _EFI_FV_LIB_H
|
||||
#define _EFI_FV_LIB_H
|
||||
|
||||
//
|
||||
// Include files
|
||||
//
|
||||
#include <string.h>
|
||||
|
||||
#include <Common/UefiBaseTypes.h>
|
||||
#include <Common/EfiImage.h>
|
||||
#include <Common/FirmwareVolumeImageFormat.h>
|
||||
#include <Common/FirmwareFileSystem.h>
|
||||
#include <Common/FirmwareVolumeHeader.h>
|
||||
#include <Common/MultiPhase.h>
|
||||
|
||||
EFI_STATUS
|
||||
InitializeFvLib (
|
||||
IN VOID *Fv,
|
||||
IN UINT32 FvLength
|
||||
)
|
||||
;
|
||||
|
||||
EFI_STATUS
|
||||
GetFvHeader (
|
||||
OUT EFI_FIRMWARE_VOLUME_HEADER **FvHeader,
|
||||
OUT UINT32 *FvLength
|
||||
)
|
||||
;
|
||||
|
||||
EFI_STATUS
|
||||
GetNextFile (
|
||||
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
|
||||
)
|
||||
;
|
||||
|
||||
EFI_STATUS
|
||||
GetFileByType (
|
||||
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
|
||||
)
|
||||
;
|
||||
//
|
||||
// will not parse compressed sections
|
||||
//
|
||||
EFI_STATUS
|
||||
VerifyFv (
|
||||
IN EFI_FIRMWARE_VOLUME_HEADER *FvHeader
|
||||
)
|
||||
;
|
||||
|
||||
EFI_STATUS
|
||||
VerifyFfsFile (
|
||||
IN EFI_FFS_FILE_HEADER *FfsHeader
|
||||
)
|
||||
;
|
||||
|
||||
/*++
|
||||
|
||||
Routine Description:
|
||||
|
||||
Verify the current pointer points to a FFS file header.
|
||||
|
||||
Arguments:
|
||||
|
||||
FfsHeader Pointer to an alleged FFS file.
|
||||
|
||||
Returns:
|
||||
|
||||
EFI_SUCCESS The Ffs header is valid.
|
||||
EFI_NOT_FOUND This "file" is the beginning of free space.
|
||||
EFI_VOLUME_CORRUPTED The Ffs header is not valid.
|
||||
|
||||
--*/
|
||||
UINT32
|
||||
GetLength (
|
||||
UINT8 *ThreeByteLength
|
||||
)
|
||||
;
|
||||
|
||||
/*++
|
||||
|
||||
Routine Description:
|
||||
|
||||
Converts a three byte length value into a UINT32.
|
||||
|
||||
Arguments:
|
||||
|
||||
ThreeByteLength Pointer to the first of the 3 byte length.
|
||||
|
||||
Returns:
|
||||
|
||||
UINT32 Size of the section
|
||||
|
||||
--*/
|
||||
EFI_STATUS
|
||||
GetErasePolarity (
|
||||
OUT BOOLEAN *ErasePolarity
|
||||
)
|
||||
;
|
||||
|
||||
/*++
|
||||
|
||||
Routine Description:
|
||||
|
||||
This function returns with the FV erase polarity. If the erase polarity
|
||||
for a bit is 1, the function return TRUE.
|
||||
|
||||
Arguments:
|
||||
|
||||
ErasePolarity A pointer to the erase polarity.
|
||||
|
||||
Returns:
|
||||
|
||||
EFI_SUCCESS The function completed successfully.
|
||||
EFI_INVALID_PARAMETER One of the input parameters was invalid.
|
||||
|
||||
--*/
|
||||
UINT8
|
||||
GetFileState (
|
||||
IN BOOLEAN ErasePolarity,
|
||||
IN EFI_FFS_FILE_HEADER *FfsHeader
|
||||
)
|
||||
;
|
||||
|
||||
/*++
|
||||
|
||||
Routine Description:
|
||||
|
||||
This function returns a the highest state bit in the FFS that is set.
|
||||
It in no way validate the FFS file.
|
||||
|
||||
Arguments:
|
||||
|
||||
ErasePolarity The erase polarity for the file state bits.
|
||||
FfsHeader Pointer to a FFS file.
|
||||
|
||||
Returns:
|
||||
|
||||
UINT8 The hightest set state of the file.
|
||||
|
||||
--*/
|
||||
#endif
|
||||
516
Tools/CodeTools/Source/Common/MyAlloc.c
Normal file
516
Tools/CodeTools/Source/Common/MyAlloc.c
Normal file
@ -0,0 +1,516 @@
|
||||
/*++
|
||||
|
||||
Copyright (c) 2004, Intel Corporation
|
||||
All rights reserved. This program and the accompanying materials
|
||||
are licensed and made available under the terms and conditions of the BSD License
|
||||
which accompanies this distribution. The full text of the license may be found at
|
||||
http://opensource.org/licenses/bsd-license.php
|
||||
|
||||
THE PROGRAM IS DISTRIBUTED UNDER THE BSD LICENSE ON AN "AS IS" BASIS,
|
||||
WITHOUT WARRANTIES OR REPRESENTATIONS OF ANY KIND, EITHER EXPRESS OR IMPLIED.
|
||||
|
||||
Module Name:
|
||||
|
||||
MyAlloc.c
|
||||
|
||||
Abstract:
|
||||
|
||||
File for memory allocation tracking functions.
|
||||
|
||||
--*/
|
||||
|
||||
#include "MyAlloc.h"
|
||||
|
||||
#if USE_MYALLOC
|
||||
//
|
||||
// Get back to original alloc/free calls.
|
||||
//
|
||||
#undef malloc
|
||||
#undef calloc
|
||||
#undef realloc
|
||||
#undef free
|
||||
//
|
||||
// Start of allocation list.
|
||||
//
|
||||
static MY_ALLOC_STRUCT *MyAllocData = NULL;
|
||||
|
||||
//
|
||||
//
|
||||
//
|
||||
static UINT32 MyAllocHeadMagik = MYALLOC_HEAD_MAGIK;
|
||||
static UINT32 MyAllocTailMagik = MYALLOC_TAIL_MAGIK;
|
||||
|
||||
//
|
||||
// ////////////////////////////////////////////////////////////////////////////
|
||||
//
|
||||
//
|
||||
VOID
|
||||
MyCheck (
|
||||
BOOLEAN Final,
|
||||
UINT8 File[],
|
||||
UINTN Line
|
||||
)
|
||||
// *++
|
||||
// Description:
|
||||
//
|
||||
// Check for corruptions in the allocated memory chain. If a corruption
|
||||
// is detection program operation stops w/ an exit(1) call.
|
||||
//
|
||||
// Parameters:
|
||||
//
|
||||
// Final := When FALSE, MyCheck() returns if the allocated memory chain
|
||||
// has not been corrupted. When TRUE, MyCheck() returns if there
|
||||
// are no un-freed allocations. If there are un-freed allocations,
|
||||
// they are displayed and exit(1) is called.
|
||||
//
|
||||
//
|
||||
// File := Set to __FILE__ by macro expansion.
|
||||
//
|
||||
// Line := Set to __LINE__ by macro expansion.
|
||||
//
|
||||
// Returns:
|
||||
//
|
||||
// n/a
|
||||
//
|
||||
// --*/
|
||||
//
|
||||
{
|
||||
MY_ALLOC_STRUCT *Tmp;
|
||||
|
||||
//
|
||||
// Check parameters.
|
||||
//
|
||||
if (File == NULL || Line == 0) {
|
||||
printf (
|
||||
"\nMyCheck(Final=%u, File=%xh, Line=%u)"
|
||||
"Invalid parameter(s).\n",
|
||||
Final,
|
||||
File,
|
||||
Line
|
||||
);
|
||||
|
||||
exit (1);
|
||||
}
|
||||
|
||||
if (strlen (File) == 0) {
|
||||
printf (
|
||||
"\nMyCheck(Final=%u, File=%s, Line=%u)"
|
||||
"Invalid parameter.\n",
|
||||
Final,
|
||||
File,
|
||||
Line
|
||||
);
|
||||
|
||||
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)) {
|
||||
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",
|
||||
Final,
|
||||
File,
|
||||
Line,
|
||||
Tmp->File,
|
||||
Tmp->Line,
|
||||
Tmp->Size,
|
||||
*(UINT32 *) (Tmp->Buffer),
|
||||
*(UINT32 *) (&Tmp->Buffer[Tmp->Size + sizeof (UINT32)])
|
||||
);
|
||||
|
||||
exit (1);
|
||||
}
|
||||
//
|
||||
// If Final is TRUE, display the state of the structure chain.
|
||||
//
|
||||
if (Final) {
|
||||
if (MyAllocData != NULL) {
|
||||
printf (
|
||||
"\nMyCheck(Final=%u, File=%s, Line=%u)"
|
||||
"\nSome allocated items have not been freed.\n",
|
||||
Final,
|
||||
File,
|
||||
Line
|
||||
);
|
||||
|
||||
for (Tmp = MyAllocData; Tmp != NULL; Tmp = Tmp->Next) {
|
||||
printf (
|
||||
"File=%s, Line=%u, nSize=%u, Head=%xh, Tail=%xh\n",
|
||||
Tmp->File,
|
||||
Tmp->Line,
|
||||
Tmp->Size,
|
||||
*(UINT32 *) (Tmp->Buffer),
|
||||
*(UINT32 *) (&Tmp->Buffer[Tmp->Size + sizeof (UINT32)])
|
||||
);
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
//
|
||||
// ////////////////////////////////////////////////////////////////////////////
|
||||
//
|
||||
//
|
||||
VOID *
|
||||
MyAlloc (
|
||||
UINTN Size,
|
||||
UINT8 File[],
|
||||
UINTN Line
|
||||
)
|
||||
// *++
|
||||
// Description:
|
||||
//
|
||||
// Allocate a new link in the allocation chain along with enough storage
|
||||
// for the File[] string, requested Size and alignment overhead. If
|
||||
// memory cannot be allocated or the allocation chain has been corrupted,
|
||||
// exit(1) will be called.
|
||||
//
|
||||
// Parameters:
|
||||
//
|
||||
// Size := Number of bytes (UINT8) requested by the called.
|
||||
// Size cannot be zero.
|
||||
//
|
||||
// File := Set to __FILE__ by macro expansion.
|
||||
//
|
||||
// Line := Set to __LINE__ by macro expansion.
|
||||
//
|
||||
// Returns:
|
||||
//
|
||||
// Pointer to the caller's buffer.
|
||||
//
|
||||
// --*/
|
||||
//
|
||||
{
|
||||
MY_ALLOC_STRUCT *Tmp;
|
||||
UINTN Len;
|
||||
|
||||
//
|
||||
// Check for invalid parameters.
|
||||
//
|
||||
if (Size == 0 || File == NULL || Line == 0) {
|
||||
printf (
|
||||
"\nMyAlloc(Size=%u, File=%xh, Line=%u)"
|
||||
"\nInvalid parameter(s).\n",
|
||||
Size,
|
||||
File,
|
||||
Line
|
||||
);
|
||||
|
||||
exit (1);
|
||||
}
|
||||
|
||||
Len = strlen (File);
|
||||
if (Len == 0) {
|
||||
printf (
|
||||
"\nMyAlloc(Size=%u, File=%s, Line=%u)"
|
||||
"\nInvalid parameter.\n",
|
||||
Size,
|
||||
File,
|
||||
Line
|
||||
);
|
||||
|
||||
exit (1);
|
||||
}
|
||||
//
|
||||
// Check the allocation list for corruption.
|
||||
//
|
||||
MyCheck (0, __FILE__, __LINE__);
|
||||
|
||||
//
|
||||
// Allocate a new entry.
|
||||
//
|
||||
Tmp = calloc (
|
||||
1,
|
||||
sizeof (MY_ALLOC_STRUCT) + Len + 1 + sizeof (UINT64) + Size + (sizeof MyAllocHeadMagik) + (sizeof MyAllocTailMagik)
|
||||
);
|
||||
|
||||
if (Tmp == NULL) {
|
||||
printf (
|
||||
"\nMyAlloc(Size=%u, File=%s, Line=%u)"
|
||||
"\nOut of memory.\n",
|
||||
Size,
|
||||
File,
|
||||
Line
|
||||
);
|
||||
|
||||
exit (1);
|
||||
}
|
||||
//
|
||||
// Fill in the new entry.
|
||||
//
|
||||
Tmp->File = ((UINT8 *) Tmp) + sizeof (MY_ALLOC_STRUCT);
|
||||
strcpy (Tmp->File, File);
|
||||
Tmp->Line = Line;
|
||||
Tmp->Size = Size;
|
||||
Tmp->Buffer = (UINT8 *) (((UINTN) Tmp + Len + 9) &~7);
|
||||
|
||||
memcpy (Tmp->Buffer, &MyAllocHeadMagik, sizeof MyAllocHeadMagik);
|
||||
|
||||
memcpy (
|
||||
&Tmp->Buffer[Size + sizeof (UINT32)],
|
||||
&MyAllocTailMagik,
|
||||
sizeof MyAllocTailMagik
|
||||
);
|
||||
|
||||
Tmp->Next = MyAllocData;
|
||||
Tmp->Cksum = (UINTN) Tmp + (UINTN) (Tmp->Next) + Tmp->Line + Tmp->Size + (UINTN) (Tmp->File) + (UINTN) (Tmp->Buffer);
|
||||
|
||||
MyAllocData = Tmp;
|
||||
|
||||
return Tmp->Buffer + sizeof (UINT32);
|
||||
}
|
||||
//
|
||||
// ////////////////////////////////////////////////////////////////////////////
|
||||
//
|
||||
//
|
||||
VOID *
|
||||
MyRealloc (
|
||||
VOID *Ptr,
|
||||
UINTN Size,
|
||||
UINT8 File[],
|
||||
UINTN Line
|
||||
)
|
||||
// *++
|
||||
// Description:
|
||||
//
|
||||
// This does a MyAlloc(), memcpy() and MyFree(). There is no optimization
|
||||
// for shrinking or expanding buffers. An invalid parameter will cause
|
||||
// MyRealloc() to fail with a call to exit(1).
|
||||
//
|
||||
// Parameters:
|
||||
//
|
||||
// Ptr := Pointer to the caller's buffer to be re-allocated.
|
||||
//
|
||||
// Size := Size of new buffer. Size cannot be zero.
|
||||
//
|
||||
// File := Set to __FILE__ by macro expansion.
|
||||
//
|
||||
// Line := Set to __LINE__ by macro expansion.
|
||||
//
|
||||
// Returns:
|
||||
//
|
||||
// Pointer to new caller's buffer.
|
||||
//
|
||||
// --*/
|
||||
//
|
||||
{
|
||||
MY_ALLOC_STRUCT *Tmp;
|
||||
VOID *Buffer;
|
||||
|
||||
//
|
||||
// Check for invalid parameter(s).
|
||||
//
|
||||
if (Size == 0 || File == NULL || Line == 0) {
|
||||
printf (
|
||||
"\nMyRealloc(Ptr=%xh, Size=%u, File=%xh, Line=%u)"
|
||||
"\nInvalid parameter(s).\n",
|
||||
Ptr,
|
||||
Size,
|
||||
File,
|
||||
Line
|
||||
);
|
||||
|
||||
exit (1);
|
||||
}
|
||||
|
||||
if (strlen (File) == 0) {
|
||||
printf (
|
||||
"\nMyRealloc(Ptr=%xh, Size=%u, File=%s, Line=%u)"
|
||||
"\nInvalid parameter.\n",
|
||||
Ptr,
|
||||
Size,
|
||||
File,
|
||||
Line
|
||||
);
|
||||
|
||||
exit (1);
|
||||
}
|
||||
//
|
||||
// Find existing buffer in allocation list.
|
||||
//
|
||||
if (Ptr == NULL) {
|
||||
Tmp = NULL;
|
||||
} else if (&MyAllocData->Buffer[sizeof (UINT32)] == Ptr) {
|
||||
Tmp = MyAllocData;
|
||||
} else {
|
||||
for (Tmp = MyAllocData;; Tmp = Tmp->Next) {
|
||||
if (Tmp->Next == NULL) {
|
||||
printf (
|
||||
"\nMyRealloc(Ptr=%xh, Size=%u, File=%s, Line=%u)"
|
||||
"\nCould not find buffer.\n",
|
||||
Ptr,
|
||||
Size,
|
||||
File,
|
||||
Line
|
||||
);
|
||||
|
||||
exit (1);
|
||||
}
|
||||
|
||||
Tmp = Tmp->Next;
|
||||
}
|
||||
}
|
||||
//
|
||||
// Allocate new buffer, copy old data, free old buffer.
|
||||
//
|
||||
Buffer = MyAlloc (Size, File, Line);
|
||||
|
||||
if (Buffer != NULL && Tmp != NULL) {
|
||||
memcpy (
|
||||
Buffer,
|
||||
&Tmp->Buffer[sizeof (UINT32)],
|
||||
((Size <= Tmp->Size) ? Size : Tmp->Size)
|
||||
);
|
||||
|
||||
MyFree (Ptr, __FILE__, __LINE__);
|
||||
}
|
||||
|
||||
return Buffer;
|
||||
}
|
||||
//
|
||||
// ////////////////////////////////////////////////////////////////////////////
|
||||
//
|
||||
//
|
||||
VOID
|
||||
MyFree (
|
||||
VOID *Ptr,
|
||||
UINT8 File[],
|
||||
UINTN Line
|
||||
)
|
||||
// *++
|
||||
// Description:
|
||||
//
|
||||
// Release a previously allocated buffer. Invalid parameters will cause
|
||||
// MyFree() to fail with an exit(1) call.
|
||||
//
|
||||
// Parameters:
|
||||
//
|
||||
// Ptr := Pointer to the caller's buffer to be freed.
|
||||
// A NULL pointer will be ignored.
|
||||
//
|
||||
// File := Set to __FILE__ by macro expansion.
|
||||
//
|
||||
// Line := Set to __LINE__ by macro expansion.
|
||||
//
|
||||
// Returns:
|
||||
//
|
||||
// n/a
|
||||
//
|
||||
// --*/
|
||||
//
|
||||
{
|
||||
MY_ALLOC_STRUCT *Tmp;
|
||||
MY_ALLOC_STRUCT *Tmp2;
|
||||
|
||||
//
|
||||
// Check for invalid parameter(s).
|
||||
//
|
||||
if (File == NULL || Line == 0) {
|
||||
printf (
|
||||
"\nMyFree(Ptr=%xh, File=%xh, Line=%u)"
|
||||
"\nInvalid parameter(s).\n",
|
||||
Ptr,
|
||||
File,
|
||||
Line
|
||||
);
|
||||
|
||||
exit (1);
|
||||
}
|
||||
|
||||
if (strlen (File) == 0) {
|
||||
printf (
|
||||
"\nMyFree(Ptr=%xh, File=%s, Line=%u)"
|
||||
"\nInvalid parameter.\n",
|
||||
Ptr,
|
||||
File,
|
||||
Line
|
||||
);
|
||||
|
||||
exit (1);
|
||||
}
|
||||
//
|
||||
// Freeing NULL is always valid.
|
||||
//
|
||||
if (Ptr == NULL) {
|
||||
return ;
|
||||
}
|
||||
//
|
||||
// Fail if nothing is allocated.
|
||||
//
|
||||
if (MyAllocData == NULL) {
|
||||
printf (
|
||||
"\nMyFree(Ptr=%xh, File=%s, Line=%u)"
|
||||
"\nCalled before memory allocated.\n",
|
||||
Ptr,
|
||||
File,
|
||||
Line
|
||||
);
|
||||
|
||||
exit (1);
|
||||
}
|
||||
//
|
||||
// Check for corrupted allocation list.
|
||||
//
|
||||
MyCheck (0, __FILE__, __LINE__);
|
||||
|
||||
//
|
||||
// Need special check for first item in list.
|
||||
//
|
||||
if (&MyAllocData->Buffer[sizeof (UINT32)] == Ptr) {
|
||||
//
|
||||
// Unlink first item in list.
|
||||
//
|
||||
Tmp = MyAllocData;
|
||||
MyAllocData = MyAllocData->Next;
|
||||
} else {
|
||||
//
|
||||
// Walk list looking for matching item.
|
||||
//
|
||||
for (Tmp = MyAllocData;; Tmp = Tmp->Next) {
|
||||
//
|
||||
// Fail if end of list is reached.
|
||||
//
|
||||
if (Tmp->Next == NULL) {
|
||||
printf (
|
||||
"\nMyFree(Ptr=%xh, File=%s, Line=%u)\n"
|
||||
"\nNot found.\n",
|
||||
Ptr,
|
||||
File,
|
||||
Line
|
||||
);
|
||||
|
||||
exit (1);
|
||||
}
|
||||
//
|
||||
// Leave loop when match is found.
|
||||
//
|
||||
if (&Tmp->Next->Buffer[sizeof (UINT32)] == Ptr) {
|
||||
break;
|
||||
}
|
||||
}
|
||||
//
|
||||
// Unlink item from list.
|
||||
//
|
||||
Tmp2 = Tmp->Next;
|
||||
Tmp->Next = Tmp->Next->Next;
|
||||
Tmp = Tmp2;
|
||||
}
|
||||
//
|
||||
// Release item.
|
||||
//
|
||||
free (Tmp);
|
||||
}
|
||||
|
||||
#endif /* USE_MYALLOC */
|
||||
|
||||
/* eof - MyAlloc.c */
|
||||
222
Tools/CodeTools/Source/Common/MyAlloc.h
Normal file
222
Tools/CodeTools/Source/Common/MyAlloc.h
Normal file
@ -0,0 +1,222 @@
|
||||
/*++
|
||||
|
||||
Copyright (c) 2004, Intel Corporation
|
||||
All rights reserved. This program and the accompanying materials
|
||||
are licensed and made available under the terms and conditions of the BSD License
|
||||
which accompanies this distribution. The full text of the license may be found at
|
||||
http://opensource.org/licenses/bsd-license.php
|
||||
|
||||
THE PROGRAM IS DISTRIBUTED UNDER THE BSD LICENSE ON AN "AS IS" BASIS,
|
||||
WITHOUT WARRANTIES OR REPRESENTATIONS OF ANY KIND, EITHER EXPRESS OR IMPLIED.
|
||||
|
||||
Module Name:
|
||||
|
||||
MyAlloc.h
|
||||
|
||||
Abstract:
|
||||
|
||||
Header file for memory allocation tracking functions.
|
||||
|
||||
--*/
|
||||
|
||||
#ifndef _MYALLOC_H_
|
||||
#define _MYALLOC_H_
|
||||
|
||||
#include <stdio.h>
|
||||
#include <stdlib.h>
|
||||
#include <string.h>
|
||||
|
||||
#include <Common/BaseTypes.h>
|
||||
|
||||
//
|
||||
// Default operation is to use the memory allocation tracking functions.
|
||||
// To over-ride add "#define USE_MYALLOC 0" to your program header and/or
|
||||
// source files as needed. Or, just do not include this header file in
|
||||
// your project.
|
||||
//
|
||||
#ifndef USE_MYALLOC
|
||||
#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__)
|
||||
|
||||
//
|
||||
// Structure for checking/tracking memory allocations.
|
||||
//
|
||||
typedef struct MyAllocStruct {
|
||||
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 +
|
||||
// (UINTN)Buffer;
|
||||
//
|
||||
// Next := Pointer to next allocation structure in the list.
|
||||
//
|
||||
// Line := __LINE__
|
||||
//
|
||||
// Size := Size of allocation request.
|
||||
//
|
||||
// File := Pointer to __FILE__ string stored immediately following
|
||||
// MY_ALLOC_STRUCT in memory.
|
||||
//
|
||||
// Buffer := Pointer to UINT32 aligned storage immediately following
|
||||
// the NULL terminated __FILE__ string. This is UINT32
|
||||
// aligned because the underflow signature is 32-bits and
|
||||
// this will place the first caller address on a 64-bit
|
||||
// boundary.
|
||||
//
|
||||
//
|
||||
// Signatures used to check for buffer overflow/underflow conditions.
|
||||
//
|
||||
#define MYALLOC_HEAD_MAGIK 0xBADFACED
|
||||
#define MYALLOC_TAIL_MAGIK 0xDEADBEEF
|
||||
|
||||
VOID
|
||||
MyCheck (
|
||||
BOOLEAN Final,
|
||||
UINT8 File[],
|
||||
UINTN Line
|
||||
)
|
||||
;
|
||||
//
|
||||
// *++
|
||||
// Description:
|
||||
//
|
||||
// Check for corruptions in the allocated memory chain. If a corruption
|
||||
// is detection program operation stops w/ an exit(1) call.
|
||||
//
|
||||
// Parameters:
|
||||
//
|
||||
// Final := When FALSE, MyCheck() returns if the allocated memory chain
|
||||
// has not been corrupted. When TRUE, MyCheck() returns if there
|
||||
// are no un-freed allocations. If there are un-freed allocations,
|
||||
// they are displayed and exit(1) is called.
|
||||
//
|
||||
//
|
||||
// File := Set to __FILE__ by macro expansion.
|
||||
//
|
||||
// Line := Set to __LINE__ by macro expansion.
|
||||
//
|
||||
// Returns:
|
||||
//
|
||||
// n/a
|
||||
//
|
||||
// --*/
|
||||
//
|
||||
VOID *
|
||||
MyAlloc (
|
||||
UINTN Size,
|
||||
UINT8 File[],
|
||||
UINTN Line
|
||||
)
|
||||
;
|
||||
//
|
||||
// *++
|
||||
// Description:
|
||||
//
|
||||
// Allocate a new link in the allocation chain along with enough storage
|
||||
// for the File[] string, requested Size and alignment overhead. If
|
||||
// memory cannot be allocated or the allocation chain has been corrupted,
|
||||
// exit(1) will be called.
|
||||
//
|
||||
// Parameters:
|
||||
//
|
||||
// Size := Number of bytes (UINT8) requested by the called.
|
||||
// Size cannot be zero.
|
||||
//
|
||||
// File := Set to __FILE__ by macro expansion.
|
||||
//
|
||||
// Line := Set to __LINE__ by macro expansion.
|
||||
//
|
||||
// Returns:
|
||||
//
|
||||
// Pointer to the caller's buffer.
|
||||
//
|
||||
// --*/
|
||||
//
|
||||
VOID *
|
||||
MyRealloc (
|
||||
VOID *Ptr,
|
||||
UINTN Size,
|
||||
UINT8 File[],
|
||||
UINTN Line
|
||||
)
|
||||
;
|
||||
//
|
||||
// *++
|
||||
// Description:
|
||||
//
|
||||
// This does a MyAlloc(), memcpy() and MyFree(). There is no optimization
|
||||
// for shrinking or expanding buffers. An invalid parameter will cause
|
||||
// MyRealloc() to fail with a call to exit(1).
|
||||
//
|
||||
// Parameters:
|
||||
//
|
||||
// Ptr := Pointer to the caller's buffer to be re-allocated.
|
||||
// Ptr cannot be NULL.
|
||||
//
|
||||
// Size := Size of new buffer. Size cannot be zero.
|
||||
//
|
||||
// File := Set to __FILE__ by macro expansion.
|
||||
//
|
||||
// Line := Set to __LINE__ by macro expansion.
|
||||
//
|
||||
// Returns:
|
||||
//
|
||||
// Pointer to new caller's buffer.
|
||||
//
|
||||
// --*/
|
||||
//
|
||||
VOID
|
||||
MyFree (
|
||||
VOID *Ptr,
|
||||
UINT8 File[],
|
||||
UINTN Line
|
||||
)
|
||||
;
|
||||
//
|
||||
// *++
|
||||
// Description:
|
||||
//
|
||||
// Release a previously allocated buffer. Invalid parameters will cause
|
||||
// MyFree() to fail with an exit(1) call.
|
||||
//
|
||||
// Parameters:
|
||||
//
|
||||
// Ptr := Pointer to the caller's buffer to be freed.
|
||||
// A NULL pointer will be ignored.
|
||||
//
|
||||
// File := Set to __FILE__ by macro expansion.
|
||||
//
|
||||
// Line := Set to __LINE__ by macro expansion.
|
||||
//
|
||||
// Returns:
|
||||
//
|
||||
// n/a
|
||||
//
|
||||
// --*/
|
||||
//
|
||||
#else /* USE_MYALLOC */
|
||||
|
||||
//
|
||||
// Nothing to do when USE_MYALLOC is zero.
|
||||
//
|
||||
#define alloc_check(final)
|
||||
|
||||
#endif /* USE_MYALLOC */
|
||||
#endif /* _MYALLOC_H_ */
|
||||
|
||||
/* eof - MyAlloc.h */
|
||||
630
Tools/CodeTools/Source/Common/ParseInf.c
Normal file
630
Tools/CodeTools/Source/Common/ParseInf.c
Normal file
@ -0,0 +1,630 @@
|
||||
/*++
|
||||
|
||||
Copyright (c) 2004, Intel Corporation
|
||||
All rights reserved. This program and the accompanying materials
|
||||
are licensed and made available under the terms and conditions of the BSD License
|
||||
which accompanies this distribution. The full text of the license may be found at
|
||||
http://opensource.org/licenses/bsd-license.php
|
||||
|
||||
THE PROGRAM IS DISTRIBUTED UNDER THE BSD LICENSE ON AN "AS IS" BASIS,
|
||||
WITHOUT WARRANTIES OR REPRESENTATIONS OF ANY KIND, EITHER EXPRESS OR IMPLIED.
|
||||
|
||||
Module Name:
|
||||
|
||||
ParseInf.c
|
||||
|
||||
Abstract:
|
||||
|
||||
This contains some useful functions for parsing INF files.
|
||||
|
||||
--*/
|
||||
|
||||
#include <assert.h>
|
||||
#include <string.h>
|
||||
#include <ctype.h>
|
||||
#include <stdlib.h>
|
||||
#include "ParseInf.h"
|
||||
|
||||
#ifndef _MAX_PATH
|
||||
#define _MAX_PATH 500
|
||||
#endif
|
||||
|
||||
CHAR8 *
|
||||
ReadLine (
|
||||
IN MEMORY_FILE *InputFile,
|
||||
IN OUT CHAR8 *InputBuffer,
|
||||
IN UINTN MaxLength
|
||||
)
|
||||
/*++
|
||||
|
||||
Routine Description:
|
||||
|
||||
This function reads a line, stripping any comments.
|
||||
The function reads a string from the input stream argument and stores it in
|
||||
the input string. ReadLine reads characters from the current file position
|
||||
to and including the first newline character, to the end of the stream, or
|
||||
until the number of characters read is equal to MaxLength - 1, whichever
|
||||
comes first. The newline character, if read, is replaced with a \0.
|
||||
|
||||
Arguments:
|
||||
|
||||
InputFile Memory file image.
|
||||
InputBuffer Buffer to read into, must be _MAX_PATH size.
|
||||
MaxLength The maximum size of the input buffer.
|
||||
|
||||
Returns:
|
||||
|
||||
NULL if error or EOF
|
||||
InputBuffer otherwise
|
||||
|
||||
--*/
|
||||
{
|
||||
CHAR8 *CharPtr;
|
||||
CHAR8 *EndOfLine;
|
||||
UINTN CharsToCopy;
|
||||
|
||||
//
|
||||
// Verify input parameters are not null
|
||||
//
|
||||
assert (InputBuffer);
|
||||
assert (InputFile->FileImage);
|
||||
assert (InputFile->Eof);
|
||||
assert (InputFile->CurrentFilePointer);
|
||||
|
||||
//
|
||||
// Check for end of file condition
|
||||
//
|
||||
if (InputFile->CurrentFilePointer >= InputFile->Eof) {
|
||||
return NULL;
|
||||
}
|
||||
//
|
||||
// Find the next newline char
|
||||
//
|
||||
EndOfLine = strchr (InputFile->CurrentFilePointer, '\n');
|
||||
|
||||
//
|
||||
// Determine the number of characters to copy.
|
||||
//
|
||||
if (EndOfLine == 0) {
|
||||
//
|
||||
// If no newline found, copy to the end of the file.
|
||||
//
|
||||
CharsToCopy = InputFile->Eof - InputFile->CurrentFilePointer;
|
||||
} else if (EndOfLine >= InputFile->Eof) {
|
||||
//
|
||||
// If the newline found was beyond the end of file, copy to the eof.
|
||||
//
|
||||
CharsToCopy = InputFile->Eof - InputFile->CurrentFilePointer;
|
||||
} else {
|
||||
//
|
||||
// Newline found in the file.
|
||||
//
|
||||
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.
|
||||
//
|
||||
if (CharsToCopy > MaxLength - 1) {
|
||||
CharsToCopy = MaxLength - 1;
|
||||
}
|
||||
//
|
||||
// Copy the line.
|
||||
//
|
||||
memcpy (InputBuffer, InputFile->CurrentFilePointer, CharsToCopy);
|
||||
|
||||
//
|
||||
// Add the null termination over the 0x0D
|
||||
//
|
||||
InputBuffer[CharsToCopy - 1] = '\0';
|
||||
|
||||
//
|
||||
// Increment the current file pointer (include the 0x0A)
|
||||
//
|
||||
InputFile->CurrentFilePointer += CharsToCopy + 1;
|
||||
|
||||
//
|
||||
// Strip any comments
|
||||
//
|
||||
CharPtr = strstr (InputBuffer, "//");
|
||||
if (CharPtr != 0) {
|
||||
CharPtr[0] = 0;
|
||||
}
|
||||
//
|
||||
// Return the string
|
||||
//
|
||||
return InputBuffer;
|
||||
}
|
||||
|
||||
BOOLEAN
|
||||
FindSection (
|
||||
IN MEMORY_FILE *InputFile,
|
||||
IN CHAR8 *Section
|
||||
)
|
||||
/*++
|
||||
|
||||
Routine Description:
|
||||
|
||||
This function parses a file from the beginning to find a section.
|
||||
The section string may be anywhere within a line.
|
||||
|
||||
Arguments:
|
||||
|
||||
InputFile Memory file image.
|
||||
Section Section to search for
|
||||
|
||||
Returns:
|
||||
|
||||
FALSE if error or EOF
|
||||
TRUE if section found
|
||||
|
||||
--*/
|
||||
{
|
||||
CHAR8 InputBuffer[_MAX_PATH];
|
||||
CHAR8 *CurrentToken;
|
||||
|
||||
//
|
||||
// Verify input is not NULL
|
||||
//
|
||||
assert (InputFile->FileImage);
|
||||
assert (InputFile->Eof);
|
||||
assert (InputFile->CurrentFilePointer);
|
||||
assert (Section);
|
||||
|
||||
//
|
||||
// Rewind to beginning of file
|
||||
//
|
||||
InputFile->CurrentFilePointer = InputFile->FileImage;
|
||||
|
||||
//
|
||||
// Read lines until the section is found
|
||||
//
|
||||
while (InputFile->CurrentFilePointer < InputFile->Eof) {
|
||||
//
|
||||
// Read a line
|
||||
//
|
||||
ReadLine (InputFile, InputBuffer, _MAX_PATH);
|
||||
|
||||
//
|
||||
// Check if the section is found
|
||||
//
|
||||
CurrentToken = strstr (InputBuffer, Section);
|
||||
if (CurrentToken != NULL) {
|
||||
return TRUE;
|
||||
}
|
||||
}
|
||||
|
||||
return FALSE;
|
||||
}
|
||||
|
||||
EFI_STATUS
|
||||
FindToken (
|
||||
IN MEMORY_FILE *InputFile,
|
||||
IN CHAR8 *Section,
|
||||
IN CHAR8 *Token,
|
||||
IN UINTN Instance,
|
||||
OUT CHAR8 *Value
|
||||
)
|
||||
/*++
|
||||
|
||||
Routine Description:
|
||||
|
||||
Finds a token value given the section and token to search for.
|
||||
|
||||
Arguments:
|
||||
|
||||
InputFile Memory file image.
|
||||
Section The section to search for, a string within [].
|
||||
Token The token to search for, e.g. EFI_PEIM_RECOVERY, followed by an = in the INF file.
|
||||
Instance The instance of the token to search for. Zero is the first instance.
|
||||
Value The string that holds the value following the =. Must be _MAX_PATH in size.
|
||||
|
||||
Returns:
|
||||
|
||||
EFI_SUCCESS Value found.
|
||||
EFI_ABORTED Format error detected in INF file.
|
||||
EFI_INVALID_PARAMETER Input argument was null.
|
||||
EFI_LOAD_ERROR Error reading from the file.
|
||||
EFI_NOT_FOUND Section/Token/Value not found.
|
||||
|
||||
--*/
|
||||
{
|
||||
CHAR8 InputBuffer[_MAX_PATH];
|
||||
CHAR8 *CurrentToken;
|
||||
BOOLEAN ParseError;
|
||||
BOOLEAN ReadError;
|
||||
UINTN Occurrance;
|
||||
|
||||
//
|
||||
// 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
|
||||
) {
|
||||
return EFI_INVALID_PARAMETER;
|
||||
}
|
||||
//
|
||||
// Initialize error codes
|
||||
//
|
||||
ParseError = FALSE;
|
||||
ReadError = FALSE;
|
||||
|
||||
//
|
||||
// Initialize our instance counter for the search token
|
||||
//
|
||||
Occurrance = 0;
|
||||
|
||||
if (FindSection (InputFile, Section)) {
|
||||
//
|
||||
// Found the desired section, find and read the desired token
|
||||
//
|
||||
do {
|
||||
//
|
||||
// Read a line from the file
|
||||
//
|
||||
if (ReadLine (InputFile, InputBuffer, _MAX_PATH) == NULL) {
|
||||
//
|
||||
// Error reading from input file
|
||||
//
|
||||
ReadError = TRUE;
|
||||
break;
|
||||
}
|
||||
//
|
||||
// Get the first non-whitespace string
|
||||
//
|
||||
CurrentToken = strtok (InputBuffer, " \t\n");
|
||||
if (CurrentToken == 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
|
||||
//
|
||||
if (strcmp (CurrentToken, Token) == 0) {
|
||||
//
|
||||
// Found it
|
||||
//
|
||||
//
|
||||
// Check if it is the correct instance
|
||||
//
|
||||
if (Instance == Occurrance) {
|
||||
//
|
||||
// Copy the contents following the =
|
||||
//
|
||||
CurrentToken = strtok (NULL, "= \t\n");
|
||||
if (CurrentToken == NULL) {
|
||||
//
|
||||
// Nothing found, parsing error
|
||||
//
|
||||
ParseError = TRUE;
|
||||
} else {
|
||||
//
|
||||
// Copy the current token to the output value
|
||||
//
|
||||
strcpy (Value, CurrentToken);
|
||||
return EFI_SUCCESS;
|
||||
}
|
||||
} else {
|
||||
//
|
||||
// Increment the occurrance found
|
||||
//
|
||||
Occurrance++;
|
||||
}
|
||||
}
|
||||
} while (
|
||||
!ParseError &&
|
||||
!ReadError &&
|
||||
InputFile->CurrentFilePointer < InputFile->Eof &&
|
||||
CurrentToken[0] != '[' &&
|
||||
Occurrance <= Instance
|
||||
);
|
||||
}
|
||||
//
|
||||
// Distinguish between read errors and INF file format errors.
|
||||
//
|
||||
if (ReadError) {
|
||||
return EFI_LOAD_ERROR;
|
||||
}
|
||||
|
||||
if (ParseError) {
|
||||
return EFI_ABORTED;
|
||||
}
|
||||
|
||||
return EFI_NOT_FOUND;
|
||||
}
|
||||
|
||||
EFI_STATUS
|
||||
StringToGuid (
|
||||
IN CHAR8 *AsciiGuidBuffer,
|
||||
OUT EFI_GUID *GuidBuffer
|
||||
)
|
||||
/*++
|
||||
|
||||
Routine Description:
|
||||
|
||||
Converts a string to an EFI_GUID. The string must be in the
|
||||
xxxxxxxx-xxxx-xxxx-xxxx-xxxxxxxxxxxx format.
|
||||
|
||||
Arguments:
|
||||
|
||||
AsciiGuidBuffer - pointer to ascii string
|
||||
GuidBuffer - pointer to destination Guid
|
||||
|
||||
Returns:
|
||||
|
||||
EFI_ABORTED Could not convert the string
|
||||
EFI_SUCCESS The string was successfully converted
|
||||
EFI_INVALID_PARAMETER Input parameter is invalid.
|
||||
|
||||
--*/
|
||||
{
|
||||
INT32 Index;
|
||||
UINTN Data1;
|
||||
UINTN Data2;
|
||||
UINTN Data3;
|
||||
UINTN Data4[8];
|
||||
|
||||
if (AsciiGuidBuffer == NULL || GuidBuffer == NULL) {
|
||||
return EFI_INVALID_PARAMETER;
|
||||
}
|
||||
//
|
||||
// Scan the guid string into the buffer
|
||||
//
|
||||
Index = sscanf (
|
||||
AsciiGuidBuffer,
|
||||
"%08x-%04x-%04x-%02x%02x-%02hx%02hx%02hx%02hx%02hx%02hx",
|
||||
&Data1,
|
||||
&Data2,
|
||||
&Data3,
|
||||
&Data4[0],
|
||||
&Data4[1],
|
||||
&Data4[2],
|
||||
&Data4[3],
|
||||
&Data4[4],
|
||||
&Data4[5],
|
||||
&Data4[6],
|
||||
&Data4[7]
|
||||
);
|
||||
|
||||
//
|
||||
// Verify the correct number of items were scanned.
|
||||
//
|
||||
if (Index != 11) {
|
||||
printf ("ERROR: Malformed GUID \"%s\".\n\n", 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];
|
||||
|
||||
return EFI_SUCCESS;
|
||||
}
|
||||
|
||||
EFI_STATUS
|
||||
AsciiStringToUint64 (
|
||||
IN CONST CHAR8 *AsciiString,
|
||||
IN BOOLEAN IsHex,
|
||||
OUT UINT64 *ReturnValue
|
||||
)
|
||||
/*++
|
||||
|
||||
Routine Description:
|
||||
|
||||
Converts a null terminated ascii string that represents a number into a
|
||||
UINT64 value. A hex number may be preceeded by a 0x, but may not be
|
||||
succeeded by an h. A number without 0x or 0X is considered to be base 10
|
||||
unless the IsHex input is true.
|
||||
|
||||
Arguments:
|
||||
|
||||
AsciiString The string to convert.
|
||||
IsHex Force the string to be treated as a hex number.
|
||||
ReturnValue The return value.
|
||||
|
||||
Returns:
|
||||
|
||||
EFI_SUCCESS Number successfully converted.
|
||||
EFI_ABORTED Invalid character encountered.
|
||||
|
||||
--*/
|
||||
{
|
||||
UINT8 Index;
|
||||
UINT64 HexNumber;
|
||||
CHAR8 CurrentChar;
|
||||
|
||||
//
|
||||
// Initialize the result
|
||||
//
|
||||
HexNumber = 0;
|
||||
|
||||
//
|
||||
// Add each character to the result
|
||||
//
|
||||
if (IsHex || (AsciiString[0] == '0' && (AsciiString[1] == 'x' || AsciiString[1] == 'X'))) {
|
||||
//
|
||||
// Verify string is a hex number
|
||||
//
|
||||
for (Index = 2; Index < strlen (AsciiString); Index++) {
|
||||
if (isxdigit (AsciiString[Index]) == 0) {
|
||||
return EFI_ABORTED;
|
||||
}
|
||||
}
|
||||
//
|
||||
// Convert the hex string.
|
||||
//
|
||||
for (Index = 2; AsciiString[Index] != '\0'; Index++) {
|
||||
CurrentChar = AsciiString[Index];
|
||||
HexNumber *= 16;
|
||||
if (CurrentChar >= '0' && CurrentChar <= '9') {
|
||||
HexNumber += CurrentChar - '0';
|
||||
} else if (CurrentChar >= 'a' && CurrentChar <= 'f') {
|
||||
HexNumber += CurrentChar - 'a' + 10;
|
||||
} else if (CurrentChar >= 'A' && CurrentChar <= 'F') {
|
||||
HexNumber += CurrentChar - 'A' + 10;
|
||||
} else {
|
||||
//
|
||||
// Unrecognized character
|
||||
//
|
||||
return EFI_ABORTED;
|
||||
}
|
||||
}
|
||||
|
||||
*ReturnValue = HexNumber;
|
||||
} else {
|
||||
//
|
||||
// Verify string is a number
|
||||
//
|
||||
for (Index = 0; Index < strlen (AsciiString); Index++) {
|
||||
if (isdigit (AsciiString[Index]) == 0) {
|
||||
return EFI_ABORTED;
|
||||
}
|
||||
}
|
||||
|
||||
*ReturnValue = atol (AsciiString);
|
||||
}
|
||||
|
||||
return EFI_SUCCESS;
|
||||
};
|
||||
|
||||
CHAR8 *
|
||||
ReadLineInStream (
|
||||
IN FILE *InputFile,
|
||||
IN OUT CHAR8 *InputBuffer
|
||||
)
|
||||
/*++
|
||||
|
||||
Routine Description:
|
||||
|
||||
This function reads a line, stripping any comments.
|
||||
// BUGBUG: This is obsolete once genmake goes away...
|
||||
|
||||
Arguments:
|
||||
|
||||
InputFile Stream pointer.
|
||||
InputBuffer Buffer to read into, must be _MAX_PATH size.
|
||||
|
||||
Returns:
|
||||
|
||||
NULL if error or EOF
|
||||
InputBuffer otherwise
|
||||
|
||||
--*/
|
||||
{
|
||||
CHAR8 *CharPtr;
|
||||
|
||||
//
|
||||
// Verify input parameters are not null
|
||||
//
|
||||
assert (InputFile);
|
||||
assert (InputBuffer);
|
||||
|
||||
//
|
||||
// Read a line
|
||||
//
|
||||
if (fgets (InputBuffer, _MAX_PATH, InputFile) == NULL) {
|
||||
return NULL;
|
||||
}
|
||||
//
|
||||
// Strip any comments
|
||||
//
|
||||
CharPtr = strstr (InputBuffer, "//");
|
||||
if (CharPtr != 0) {
|
||||
CharPtr[0] = 0;
|
||||
}
|
||||
|
||||
CharPtr = strstr (InputBuffer, "#");
|
||||
if (CharPtr != 0) {
|
||||
CharPtr[0] = 0;
|
||||
}
|
||||
//
|
||||
// Return the string
|
||||
//
|
||||
return InputBuffer;
|
||||
}
|
||||
|
||||
BOOLEAN
|
||||
FindSectionInStream (
|
||||
IN FILE *InputFile,
|
||||
IN CHAR8 *Section
|
||||
)
|
||||
/*++
|
||||
|
||||
Routine Description:
|
||||
|
||||
This function parses a stream file from the beginning to find a section.
|
||||
The section string may be anywhere within a line.
|
||||
// BUGBUG: This is obsolete once genmake goes away...
|
||||
|
||||
Arguments:
|
||||
|
||||
InputFile Stream pointer.
|
||||
Section Section to search for
|
||||
|
||||
Returns:
|
||||
|
||||
FALSE if error or EOF
|
||||
TRUE if section found
|
||||
|
||||
--*/
|
||||
{
|
||||
CHAR8 InputBuffer[_MAX_PATH];
|
||||
CHAR8 *CurrentToken;
|
||||
|
||||
//
|
||||
// Verify input is not NULL
|
||||
//
|
||||
assert (InputFile);
|
||||
assert (Section);
|
||||
|
||||
//
|
||||
// Rewind to beginning of file
|
||||
//
|
||||
if (fseek (InputFile, 0, SEEK_SET) != 0) {
|
||||
return FALSE;
|
||||
}
|
||||
//
|
||||
// Read lines until the section is found
|
||||
//
|
||||
while (feof (InputFile) == 0) {
|
||||
//
|
||||
// Read a line
|
||||
//
|
||||
ReadLineInStream (InputFile, InputBuffer);
|
||||
|
||||
//
|
||||
// Check if the section is found
|
||||
//
|
||||
CurrentToken = strstr (InputBuffer, Section);
|
||||
if (CurrentToken != NULL) {
|
||||
return TRUE;
|
||||
}
|
||||
}
|
||||
|
||||
return FALSE;
|
||||
}
|
||||
234
Tools/CodeTools/Source/Common/ParseInf.h
Normal file
234
Tools/CodeTools/Source/Common/ParseInf.h
Normal file
@ -0,0 +1,234 @@
|
||||
/*++
|
||||
|
||||
Copyright (c) 2004, Intel Corporation
|
||||
All rights reserved. This program and the accompanying materials
|
||||
are licensed and made available under the terms and conditions of the BSD License
|
||||
which accompanies this distribution. The full text of the license may be found at
|
||||
http://opensource.org/licenses/bsd-license.php
|
||||
|
||||
THE PROGRAM IS DISTRIBUTED UNDER THE BSD LICENSE ON AN "AS IS" BASIS,
|
||||
WITHOUT WARRANTIES OR REPRESENTATIONS OF ANY KIND, EITHER EXPRESS OR IMPLIED.
|
||||
|
||||
Module Name:
|
||||
|
||||
ParseInf.h
|
||||
|
||||
Abstract:
|
||||
|
||||
Header file for helper functions useful for parsing INF files.
|
||||
|
||||
--*/
|
||||
|
||||
#ifndef _EFI_PARSE_INF_H
|
||||
#define _EFI_PARSE_INF_H
|
||||
|
||||
#include <stdio.h>
|
||||
#include <stdlib.h>
|
||||
|
||||
#include <Common/UefiBaseTypes.h>
|
||||
|
||||
//
|
||||
// Common data structures
|
||||
//
|
||||
typedef struct {
|
||||
CHAR8 *FileImage;
|
||||
CHAR8 *Eof;
|
||||
CHAR8 *CurrentFilePointer;
|
||||
} MEMORY_FILE;
|
||||
|
||||
//
|
||||
// Functions declarations
|
||||
//
|
||||
CHAR8 *
|
||||
ReadLine (
|
||||
IN MEMORY_FILE *InputFile,
|
||||
IN OUT CHAR8 *InputBuffer,
|
||||
IN UINTN MaxLength
|
||||
)
|
||||
;
|
||||
|
||||
/*++
|
||||
|
||||
Routine Description:
|
||||
|
||||
This function reads a line, stripping any comments.
|
||||
The function reads a string from the input stream argument and stores it in
|
||||
the input string. ReadLine reads characters from the current file position
|
||||
to and including the first newline character, to the end of the stream, or
|
||||
until the number of characters read is equal to MaxLength - 1, whichever
|
||||
comes first. The newline character, if read, is replaced with a \0.
|
||||
|
||||
Arguments:
|
||||
|
||||
InputFile Memory file image.
|
||||
InputBuffer Buffer to read into, must be _MAX_PATH size.
|
||||
MaxLength The maximum size of the input buffer.
|
||||
|
||||
Returns:
|
||||
|
||||
NULL if error or EOF
|
||||
InputBuffer otherwise
|
||||
|
||||
--*/
|
||||
BOOLEAN
|
||||
FindSection (
|
||||
IN MEMORY_FILE *InputFile,
|
||||
IN CHAR8 *Section
|
||||
)
|
||||
;
|
||||
|
||||
/*++
|
||||
|
||||
Routine Description:
|
||||
|
||||
This function parses a file from the beginning to find a section.
|
||||
The section string may be anywhere within a line.
|
||||
|
||||
Arguments:
|
||||
|
||||
InputFile Memory file image.
|
||||
Section Section to search for
|
||||
|
||||
Returns:
|
||||
|
||||
FALSE if error or EOF
|
||||
TRUE if section found
|
||||
|
||||
--*/
|
||||
EFI_STATUS
|
||||
FindToken (
|
||||
IN MEMORY_FILE *InputFile,
|
||||
IN CHAR8 *Section,
|
||||
IN CHAR8 *Token,
|
||||
IN UINTN Instance,
|
||||
OUT CHAR8 *Value
|
||||
)
|
||||
;
|
||||
|
||||
/*++
|
||||
|
||||
Routine Description:
|
||||
|
||||
Finds a token value given the section and token to search for.
|
||||
|
||||
Arguments:
|
||||
|
||||
InputFile Memory file image.
|
||||
Section The section to search for, a string within [].
|
||||
Token The token to search for, e.g. EFI_PEIM_RECOVERY, followed by an = in the INF file.
|
||||
Instance The instance of the token to search for. Zero is the first instance.
|
||||
Value The string that holds the value following the =. Must be _MAX_PATH in size.
|
||||
|
||||
Returns:
|
||||
|
||||
EFI_SUCCESS Value found.
|
||||
EFI_ABORTED Format error detected in INF file.
|
||||
EFI_INVALID_PARAMETER Input argument was null.
|
||||
EFI_LOAD_ERROR Error reading from the file.
|
||||
EFI_NOT_FOUND Section/Token/Value not found.
|
||||
|
||||
--*/
|
||||
EFI_STATUS
|
||||
StringToGuid (
|
||||
IN CHAR8 *AsciiGuidBuffer,
|
||||
OUT EFI_GUID *GuidBuffer
|
||||
)
|
||||
;
|
||||
|
||||
/*++
|
||||
|
||||
Routine Description:
|
||||
|
||||
Converts a string to an EFI_GUID. The string must be in the
|
||||
xxxxxxxx-xxxx-xxxx-xxxx-xxxxxxxxxxxx format.
|
||||
|
||||
Arguments:
|
||||
|
||||
GuidBuffer - pointer to destination Guid
|
||||
AsciiGuidBuffer - pointer to ascii string
|
||||
|
||||
Returns:
|
||||
|
||||
EFI_ABORTED Could not convert the string
|
||||
EFI_SUCCESS The string was successfully converted
|
||||
|
||||
--*/
|
||||
EFI_STATUS
|
||||
AsciiStringToUint64 (
|
||||
IN CONST CHAR8 *AsciiString,
|
||||
IN BOOLEAN IsHex,
|
||||
OUT UINT64 *ReturnValue
|
||||
)
|
||||
;
|
||||
|
||||
/*++
|
||||
|
||||
Routine Description:
|
||||
|
||||
Converts a null terminated ascii string that represents a number into a
|
||||
UINT64 value. A hex number may be preceeded by a 0x, but may not be
|
||||
succeeded by an h. A number without 0x or 0X is considered to be base 10
|
||||
unless the IsHex input is true.
|
||||
|
||||
Arguments:
|
||||
|
||||
AsciiString The string to convert.
|
||||
IsHex Force the string to be treated as a hex number.
|
||||
ReturnValue The return value.
|
||||
|
||||
Returns:
|
||||
|
||||
EFI_SUCCESS Number successfully converted.
|
||||
EFI_ABORTED Invalid character encountered.
|
||||
|
||||
--*/
|
||||
CHAR8 *
|
||||
ReadLineInStream (
|
||||
IN FILE *InputFile,
|
||||
IN OUT CHAR8 *InputBuffer
|
||||
)
|
||||
;
|
||||
|
||||
/*++
|
||||
|
||||
Routine Description:
|
||||
|
||||
This function reads a line, stripping any comments.
|
||||
|
||||
Arguments:
|
||||
|
||||
InputFile Stream pointer.
|
||||
InputBuffer Buffer to read into, must be _MAX_PATH size.
|
||||
|
||||
Returns:
|
||||
|
||||
NULL if error or EOF
|
||||
InputBuffer otherwise
|
||||
|
||||
--*/
|
||||
BOOLEAN
|
||||
FindSectionInStream (
|
||||
IN FILE *InputFile,
|
||||
IN CHAR8 *Section
|
||||
)
|
||||
;
|
||||
|
||||
/*++
|
||||
|
||||
Routine Description:
|
||||
|
||||
This function parses a stream file from the beginning to find a section.
|
||||
The section string may be anywhere within a line.
|
||||
|
||||
Arguments:
|
||||
|
||||
InputFile Stream pointer.
|
||||
Section Section to search for
|
||||
|
||||
Returns:
|
||||
|
||||
FALSE if error or EOF
|
||||
TRUE if section found
|
||||
|
||||
--*/
|
||||
#endif
|
||||
1457
Tools/CodeTools/Source/Common/SimpleFileParsing.c
Normal file
1457
Tools/CodeTools/Source/Common/SimpleFileParsing.c
Normal file
File diff suppressed because it is too large
Load Diff
120
Tools/CodeTools/Source/Common/SimpleFileParsing.h
Normal file
120
Tools/CodeTools/Source/Common/SimpleFileParsing.h
Normal file
@ -0,0 +1,120 @@
|
||||
/*++
|
||||
|
||||
Copyright (c) 2004, Intel Corporation
|
||||
All rights reserved. This program and the accompanying materials
|
||||
are licensed and made available under the terms and conditions of the BSD License
|
||||
which accompanies this distribution. The full text of the license may be found at
|
||||
http://opensource.org/licenses/bsd-license.php
|
||||
|
||||
THE PROGRAM IS DISTRIBUTED UNDER THE BSD LICENSE ON AN "AS IS" BASIS,
|
||||
WITHOUT WARRANTIES OR REPRESENTATIONS OF ANY KIND, EITHER EXPRESS OR IMPLIED.
|
||||
|
||||
Module Name:
|
||||
|
||||
SimpleFileParsing.h
|
||||
|
||||
Abstract:
|
||||
|
||||
Function prototypes and defines for the simple file parsing routines.
|
||||
|
||||
--*/
|
||||
|
||||
#ifndef _SIMPLE_FILE_PARSING_H_
|
||||
#define _SIMPLE_FILE_PARSING_H_
|
||||
|
||||
#include <Common/UefiBaseTypes.h>
|
||||
|
||||
#define T_CHAR char
|
||||
|
||||
STATUS
|
||||
SFPInit (
|
||||
VOID
|
||||
)
|
||||
;
|
||||
|
||||
STATUS
|
||||
SFPOpenFile (
|
||||
char *FileName
|
||||
)
|
||||
;
|
||||
|
||||
BOOLEAN
|
||||
SFPIsKeyword (
|
||||
T_CHAR *Str
|
||||
)
|
||||
;
|
||||
|
||||
BOOLEAN
|
||||
SFPIsToken (
|
||||
T_CHAR *Str
|
||||
)
|
||||
;
|
||||
|
||||
BOOLEAN
|
||||
SFPGetNextToken (
|
||||
T_CHAR *Str,
|
||||
unsigned int Len
|
||||
)
|
||||
;
|
||||
|
||||
BOOLEAN
|
||||
SFPGetGuidToken (
|
||||
T_CHAR *Str,
|
||||
UINT32 Len
|
||||
)
|
||||
;
|
||||
|
||||
#define PARSE_GUID_STYLE_5_FIELDS 0
|
||||
|
||||
BOOLEAN
|
||||
SFPGetGuid (
|
||||
int GuidStyle,
|
||||
EFI_GUID *Value
|
||||
)
|
||||
;
|
||||
|
||||
BOOLEAN
|
||||
SFPSkipToToken (
|
||||
T_CHAR *Str
|
||||
)
|
||||
;
|
||||
|
||||
BOOLEAN
|
||||
SFPGetNumber (
|
||||
unsigned int *Value
|
||||
)
|
||||
;
|
||||
|
||||
BOOLEAN
|
||||
SFPGetQuotedString (
|
||||
T_CHAR *Str,
|
||||
int Length
|
||||
)
|
||||
;
|
||||
|
||||
BOOLEAN
|
||||
SFPIsEOF (
|
||||
VOID
|
||||
)
|
||||
;
|
||||
|
||||
STATUS
|
||||
SFPCloseFile (
|
||||
VOID
|
||||
)
|
||||
;
|
||||
|
||||
unsigned
|
||||
int
|
||||
SFPGetLineNumber (
|
||||
VOID
|
||||
)
|
||||
;
|
||||
|
||||
T_CHAR *
|
||||
SFPGetFileName (
|
||||
VOID
|
||||
)
|
||||
;
|
||||
|
||||
#endif // #ifndef _SIMPLE_FILE_PARSING_H_
|
||||
73
Tools/CodeTools/Source/Common/WinNtInclude.h
Normal file
73
Tools/CodeTools/Source/Common/WinNtInclude.h
Normal file
@ -0,0 +1,73 @@
|
||||
/*--
|
||||
|
||||
Copyright (c) 2006, Intel Corporation
|
||||
All rights reserved. This program and the accompanying materials
|
||||
are licensed and made available under the terms and conditions of the BSD License
|
||||
which accompanies this distribution. The full text of the license may be found at
|
||||
http://opensource.org/licenses/bsd-license.php
|
||||
|
||||
THE PROGRAM IS DISTRIBUTED UNDER THE BSD LICENSE ON AN "AS IS" BASIS,
|
||||
WITHOUT WARRANTIES OR REPRESENTATIONS OF ANY KIND, EITHER EXPRESS OR IMPLIED.
|
||||
|
||||
Module Name:
|
||||
WinNtInclude.h
|
||||
|
||||
Abstract:
|
||||
Include file for the WinNt Library
|
||||
|
||||
--*/
|
||||
|
||||
#ifndef __WIN_NT_INCLUDE_H__
|
||||
#define __WIN_NT_INCLUDE_H__
|
||||
|
||||
//
|
||||
// Win32 include files do not compile clean with /W4, so we use the warning
|
||||
// pragma to suppress the warnings for Win32 only. This way our code can stil
|
||||
// compile at /W4 (highest warning level) with /WX (warnings cause build
|
||||
// errors).
|
||||
//
|
||||
#pragma warning(disable : 4115)
|
||||
#pragma warning(disable : 4201)
|
||||
#pragma warning(disable : 4214)
|
||||
#pragma warning(disable : 4028)
|
||||
#pragma warning(disable : 4133)
|
||||
|
||||
#define GUID _WINNT_DUP_GUID_____
|
||||
#define _LIST_ENTRY _WINNT_DUP_LIST_ENTRY_FORWARD
|
||||
#define LIST_ENTRY _WINNT_DUP_LIST_ENTRY
|
||||
#define InterlockedIncrement _WINNT_DUP_InterlockedIncrement
|
||||
#define InterlockedDecrement _WINNT_DUP_InterlockedDecrement
|
||||
#define InterlockedCompareExchange64 _WINNT_DUP_InterlockedCompareExchange64
|
||||
#undef UNALIGNED
|
||||
#undef CONST
|
||||
#undef VOID
|
||||
|
||||
#ifndef __GNUC__
|
||||
#include "windows.h"
|
||||
#endif
|
||||
|
||||
#undef GUID
|
||||
#undef _LIST_ENTRY
|
||||
#undef LIST_ENTRY
|
||||
#undef InterlockedIncrement
|
||||
#undef InterlockedDecrement
|
||||
#undef InterlockedCompareExchange64
|
||||
#undef InterlockedCompareExchangePointer
|
||||
|
||||
#define VOID void
|
||||
|
||||
//
|
||||
// Prevent collisions with Windows API name macros that deal with Unicode/Not issues
|
||||
//
|
||||
#undef LoadImage
|
||||
#undef CreateEvent
|
||||
|
||||
//
|
||||
// Set the warnings back on as the EFI code must be /W4.
|
||||
//
|
||||
#pragma warning(default : 4115)
|
||||
#pragma warning(default : 4201)
|
||||
#pragma warning(default : 4214)
|
||||
|
||||
|
||||
#endif
|
||||
67
Tools/CodeTools/Source/Common/build.xml
Normal file
67
Tools/CodeTools/Source/Common/build.xml
Normal file
@ -0,0 +1,67 @@
|
||||
<?xml version="1.0" ?>
|
||||
<!--
|
||||
Copyright (c) 2006, Intel Corporation
|
||||
All rights reserved. This program and the accompanying materials
|
||||
are licensed and made available under the terms and conditions of the BSD License
|
||||
which accompanies this distribution. The full text of the license may be found at
|
||||
http://opensource.org/licenses/bsd-license.php
|
||||
|
||||
THE PROGRAM IS DISTRIBUTED UNDER THE BSD LICENSE ON AN "AS IS" BASIS,
|
||||
WITHOUT WARRANTIES OR REPRESENTATIONS OF ANY KIND, EITHER EXPRESS OR IMPLIED.
|
||||
-->
|
||||
<project default="CommonTools.lib" basedir=".">
|
||||
<!--
|
||||
EDK Common Tools Library
|
||||
Copyright (c) 2006, Intel Corporation
|
||||
-->
|
||||
|
||||
<taskdef resource="cpptasks.tasks"/>
|
||||
<typedef resource="cpptasks.types"/>
|
||||
<taskdef resource="net/sf/antcontrib/antlib.xml"/>
|
||||
|
||||
<property name="tmp" value="tmp"/>
|
||||
<property name="LibName" value="CommonTool"/>
|
||||
|
||||
<property name="LINK_OUTPUT_TYPE" value="static"/>
|
||||
<property name="BUILD_DIR" value="${PACKAGE_DIR}/Common/tmp"/>
|
||||
|
||||
<target name="CommonTools.lib" depends="init, ToolsLibrary">
|
||||
<echo message="The EDK Tool Library: ${LibName} build has completed."/>
|
||||
</target>
|
||||
|
||||
<target name="init">
|
||||
<echo message="Building the EDK Tool Library: ${LibName}"/>
|
||||
<mkdir dir="${BUILD_DIR}"/>
|
||||
</target>
|
||||
|
||||
<target name="ToolsLibrary" depends="init">
|
||||
<cc name="${ToolChain}" objdir="${BUILD_DIR}"
|
||||
outfile="${LIB_DIR}/CommonTools"
|
||||
outtype="static"
|
||||
debug="true"
|
||||
optimize="speed">
|
||||
<compilerarg value="${ExtraArgus}" if="ExtraArgus" />
|
||||
<compilerarg value="-fPIC" if="x86_64_linux"/>
|
||||
|
||||
<includepath path="${PACKAGE_DIR}/Include"/>
|
||||
<includepath path="${PACKAGE_DIR}/Include/${HostArch}"/>
|
||||
|
||||
<fileset dir="${basedir}/Common"
|
||||
includes="*.c" />
|
||||
</cc>
|
||||
</target>
|
||||
|
||||
<target name="clean">
|
||||
<echo message="Removing Intermediate Files Only from ${BUILD_DIR}"/>
|
||||
<delete dir="${BUILD_DIR}"/>
|
||||
</target>
|
||||
|
||||
<target name="cleanall">
|
||||
<echo message="Removing Object Files and the Library: ${LibName}${ext_static}"/>
|
||||
<delete failonerror="false" quiet="true" includeEmptyDirs="true">
|
||||
<fileset dir="${BUILD_DIR}"/>
|
||||
<fileset file="${LIB_DIR}/${LibName}${ext_static}"/>
|
||||
</delete>
|
||||
</target>
|
||||
|
||||
</project>
|
||||
Reference in New Issue
Block a user