mirror of https://github.com/acidanthera/audk.git
1360 lines
26 KiB
C
1360 lines
26 KiB
C
/*++
|
|
|
|
Copyright (c) 2004 - 2007, Intel Corporation. All rights reserved.<BR>
|
|
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:
|
|
|
|
EfiCommonLib.h
|
|
|
|
Abstract:
|
|
|
|
Light weight lib to support EFI drivers.
|
|
|
|
--*/
|
|
|
|
#ifndef _EFI_COMMON_LIB_H_
|
|
#define _EFI_COMMON_LIB_H_
|
|
|
|
EFI_STATUS
|
|
EfiLibGetSystemConfigurationTable (
|
|
IN EFI_GUID *TableGuid,
|
|
IN OUT VOID **Table
|
|
)
|
|
/*++
|
|
|
|
Routine Description:
|
|
|
|
Return the EFI 1.0 System Tabl entry with TableGuid
|
|
|
|
Arguments:
|
|
|
|
TableGuid - Name of entry to return in the system table
|
|
Table - Pointer in EFI system table associated with TableGuid
|
|
|
|
Returns:
|
|
|
|
EFI_SUCCESS - Table returned;
|
|
EFI_NOT_FOUND - TableGuid not in EFI system table
|
|
|
|
--*/
|
|
;
|
|
|
|
//
|
|
// ASPrint and AvSPrint definitions you must include the specific library
|
|
// to get the expected behavior from the two functions
|
|
// PEI: PeiLib
|
|
// Graphics: Dxe\Graphics\Unicode Dxe\Graphics\ASCII
|
|
// ASCII: Dxe\Print\ASCII
|
|
// Unicode: Dxe\Print\Unicode
|
|
//
|
|
UINTN
|
|
ASPrint (
|
|
OUT CHAR8 *Buffer,
|
|
IN UINTN BufferSize,
|
|
IN CONST CHAR8 *Format,
|
|
...
|
|
)
|
|
/*++
|
|
|
|
Routine Description:
|
|
|
|
Process format and place the results in Buffer for narrow chars.
|
|
|
|
Arguments:
|
|
|
|
Buffer - Narrow char buffer to print the results of the parsing of Format into.
|
|
BufferSize - Maximum number of characters to put into buffer.
|
|
Format - Format string
|
|
... - Vararg list consumed by processing Format.
|
|
|
|
Returns:
|
|
|
|
Number of characters printed.
|
|
|
|
--*/
|
|
;
|
|
|
|
UINTN
|
|
AvSPrint (
|
|
OUT CHAR8 *StartOfBuffer,
|
|
IN UINTN StrSize,
|
|
IN CONST CHAR8 *Format,
|
|
IN VA_LIST Marker
|
|
)
|
|
/*++
|
|
|
|
Routine Description:
|
|
|
|
Internal implementation of ASPrint.
|
|
Process format and place the results in Buffer for narrow chars.
|
|
|
|
Arguments:
|
|
|
|
StartOfBuffer - Narrow char buffer to print the results of the parsing of Format into.
|
|
StrSize - Maximum number of characters to put into buffer.
|
|
FormatString - Format string
|
|
Marker - Vararg list consumed by processing Format.
|
|
|
|
Returns:
|
|
|
|
Number of characters printed.
|
|
|
|
--*/
|
|
;
|
|
|
|
//
|
|
// Lib functions which can be used in both PEI and DXE pahse
|
|
//
|
|
EFI_STATUS
|
|
EfiInitializeCommonDriverLib (
|
|
IN EFI_HANDLE ImageHandle,
|
|
IN VOID *SystemTable
|
|
)
|
|
/*++
|
|
|
|
Routine Description:
|
|
|
|
Initialize lib function calling phase: PEI or DXE
|
|
|
|
Arguments:
|
|
|
|
ImageHandle - The firmware allocated handle for the EFI image.
|
|
|
|
SystemTable - A pointer to the EFI System Table.
|
|
|
|
Returns:
|
|
|
|
EFI_STATUS always returns EFI_SUCCESS
|
|
|
|
--*/
|
|
;
|
|
|
|
EFI_STATUS
|
|
EfiCommonIoRead (
|
|
IN UINT8 Width,
|
|
IN UINTN Address,
|
|
IN UINTN Count,
|
|
IN OUT VOID *Buffer
|
|
)
|
|
/*++
|
|
|
|
Routine Description:
|
|
|
|
Io read operation.
|
|
|
|
Arguments:
|
|
|
|
Width - Width of read operation
|
|
Address - Start IO address to read
|
|
Count - Read count
|
|
Buffer - Buffer to store result
|
|
|
|
Returns:
|
|
|
|
Status code
|
|
|
|
--*/
|
|
;
|
|
|
|
EFI_STATUS
|
|
EfiCommonIoWrite (
|
|
IN UINT8 Width,
|
|
IN UINTN Address,
|
|
IN UINTN Count,
|
|
IN OUT VOID *Buffer
|
|
)
|
|
/*++
|
|
|
|
Routine Description:
|
|
|
|
Io write operation.
|
|
|
|
Arguments:
|
|
|
|
Width - Width of write operation
|
|
Address - Start IO address to write
|
|
Count - Write count
|
|
Buffer - Buffer to write to the address
|
|
|
|
Returns:
|
|
|
|
Status code
|
|
|
|
--*/
|
|
;
|
|
|
|
EFI_STATUS
|
|
EfiCommonPciRead (
|
|
IN UINT8 Width,
|
|
IN UINT64 Address,
|
|
IN UINTN Count,
|
|
IN OUT VOID *Buffer
|
|
)
|
|
/*++
|
|
|
|
Routine Description:
|
|
|
|
Pci read operation
|
|
|
|
Arguments:
|
|
|
|
Width - Width of PCI read
|
|
Address - PCI address to read
|
|
Count - Read count
|
|
Buffer - Output buffer for the read
|
|
|
|
Returns:
|
|
|
|
Status code
|
|
|
|
--*/
|
|
;
|
|
|
|
EFI_STATUS
|
|
EfiCommonPciWrite (
|
|
IN UINT8 Width,
|
|
IN UINT64 Address,
|
|
IN UINTN Count,
|
|
IN OUT VOID *Buffer
|
|
)
|
|
/*++
|
|
|
|
Routine Description:
|
|
|
|
Pci write operation
|
|
|
|
Arguments:
|
|
|
|
Width - Width of PCI write
|
|
Address - PCI address to write
|
|
Count - Write count
|
|
Buffer - Buffer to write to the address
|
|
|
|
Returns:
|
|
|
|
Status code
|
|
|
|
--*/
|
|
;
|
|
|
|
BOOLEAN
|
|
EfiCompareGuid (
|
|
IN EFI_GUID *Guid1,
|
|
IN EFI_GUID *Guid2
|
|
)
|
|
/*++
|
|
|
|
Routine Description:
|
|
|
|
Compares two GUIDs
|
|
|
|
Arguments:
|
|
|
|
Guid1 - guid to compare
|
|
|
|
Guid2 - guid to compare
|
|
|
|
Returns:
|
|
TRUE if Guid1 == Guid2
|
|
FALSE if Guid1 != Guid2
|
|
|
|
--*/
|
|
;
|
|
|
|
VOID
|
|
EfiCommonLibSetMem (
|
|
IN VOID *Buffer,
|
|
IN UINTN Size,
|
|
IN UINT8 Value
|
|
)
|
|
/*++
|
|
|
|
Routine Description:
|
|
|
|
Set Buffer to Value for Size bytes.
|
|
|
|
Arguments:
|
|
|
|
Buffer - Memory to set.
|
|
|
|
Size - Number of bytes to set
|
|
|
|
Value - Value of the set operation.
|
|
|
|
Returns:
|
|
|
|
None
|
|
|
|
--*/
|
|
;
|
|
|
|
VOID
|
|
EfiCommonLibCopyMem (
|
|
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
|
|
|
|
--*/
|
|
;
|
|
|
|
INTN
|
|
EfiCompareMem (
|
|
IN VOID *MemOne,
|
|
IN VOID *MemTwo,
|
|
IN UINTN Len
|
|
)
|
|
/*++
|
|
|
|
Routine Description:
|
|
|
|
Compares two memory buffers of a given length.
|
|
|
|
Arguments:
|
|
|
|
MemOne - First memory buffer
|
|
|
|
MemTwo - Second memory buffer
|
|
|
|
Len - Length of Mem1 and Mem2 memory regions to compare
|
|
|
|
Returns:
|
|
|
|
= 0 if MemOne == MemTwo
|
|
|
|
> 0 if MemOne > MemTwo
|
|
|
|
< 0 if MemOne < MemTwo
|
|
|
|
--*/
|
|
;
|
|
|
|
VOID
|
|
EfiCommonLibZeroMem (
|
|
IN VOID *Buffer,
|
|
IN UINTN Size
|
|
)
|
|
/*++
|
|
|
|
Routine Description:
|
|
|
|
Set Buffer to 0 for Size bytes.
|
|
|
|
Arguments:
|
|
|
|
Buffer - Memory to set.
|
|
|
|
Size - Number of bytes to set
|
|
|
|
Returns:
|
|
|
|
None
|
|
|
|
--*/
|
|
;
|
|
|
|
//
|
|
// Min Max
|
|
//
|
|
#define EFI_MIN(a, b) (((a) < (b)) ? (a) : (b))
|
|
#define EFI_MAX(a, b) (((a) > (b)) ? (a) : (b))
|
|
|
|
//
|
|
// Align a pointer. The pointer represented by ptr is aligned to the bound.
|
|
// The resulting pointer is always equal or greater (by no more than bound-1)
|
|
// than the ptr. I.e., if the ptr is already aligned, the result will be equal to ptr.
|
|
// Valid values for bound are powers of two: 2, 4, 8, 16, 32 etc.
|
|
// The returned pointer is VOID* this assignment-compatible with all pointer types.
|
|
//
|
|
#define EFI_ALIGN(ptr, bound) ((VOID *) (((UINTN) (ptr) + ((UINTN) (bound) - 1)) &~((UINTN) (bound) - 1)))
|
|
|
|
//
|
|
// Alignment tests.
|
|
//
|
|
#define EFI_UINTN_ALIGN_MASK (sizeof (UINTN) - 1)
|
|
#define EFI_UINTN_ALIGNED(ptr) (((UINTN) (ptr)) & EFI_UINTN_ALIGN_MASK)
|
|
|
|
//
|
|
// Integer division with rounding to the nearest rather than truncating.
|
|
// For example 8/3=2 but EFI_IDIV_ROUND(8,3)=3. 1/3=0 and EFI_IDIV_ROUND(1,3)=0.
|
|
// A half is rounded up e.g., EFI_IDIV_ROUND(1,2)=1 but 1/2=0.
|
|
//
|
|
#define EFI_IDIV_ROUND(r, s) ((r) / (s) + (((2 * ((r) % (s))) < (s)) ? 0 : 1))
|
|
|
|
//
|
|
// ReportStatusCode.c init
|
|
//
|
|
VOID *
|
|
EfiConstructStatusCodeData (
|
|
IN UINT16 DataSize,
|
|
IN EFI_GUID *TypeGuid,
|
|
IN OUT EFI_STATUS_CODE_DATA *Data
|
|
)
|
|
/*++
|
|
|
|
Routine Description:
|
|
|
|
Construct stanader header for optional data passed into ReportStatusCode
|
|
|
|
Arguments:
|
|
|
|
DataSize - Size of optional data. Does not include EFI_STATUS_CODE_DATA header
|
|
TypeGuid - GUID to place in EFI_STATUS_CODE_DATA
|
|
Data - Buffer to use.
|
|
|
|
Returns:
|
|
|
|
Return pointer to Data buffer pointing past the end of EFI_STATUS_CODE_DATA
|
|
|
|
--*/
|
|
;
|
|
|
|
EFI_STATUS
|
|
EfiDebugVPrintWorker (
|
|
IN UINTN ErrorLevel,
|
|
IN CHAR8 *Format,
|
|
IN VA_LIST Marker,
|
|
IN UINTN BufferSize,
|
|
IN OUT VOID *Buffer
|
|
)
|
|
/*++
|
|
|
|
Routine Description:
|
|
|
|
Worker function for DEBUG(). If Error Logging hub is loaded log ASSERT
|
|
information. If Error Logging hub is not loaded do nothing.
|
|
|
|
We use UINT64 buffers due to IPF alignment concerns.
|
|
|
|
Arguments:
|
|
|
|
ErrorLevel - If error level is set do the debug print.
|
|
|
|
Format - String to use for the print, followed by Print arguments.
|
|
|
|
Marker - VarArgs
|
|
|
|
BufferSize - Size of Buffer.
|
|
|
|
Buffer - Caller allocated buffer, contains ReportStatusCode extended data
|
|
|
|
Returns:
|
|
|
|
Status code
|
|
|
|
--*/
|
|
;
|
|
|
|
EFI_STATUS
|
|
EfiDebugAssertWorker (
|
|
IN CHAR8 *FileName,
|
|
IN INTN LineNumber,
|
|
IN CHAR8 *Description,
|
|
IN UINTN BufferSize,
|
|
IN OUT VOID *Buffer
|
|
)
|
|
/*++
|
|
|
|
Routine Description:
|
|
|
|
Worker function for ASSERT (). If Error Logging hub is loaded log ASSERT
|
|
information. If Error Logging hub is not loaded DEADLOOP ().
|
|
|
|
We use UINT64 buffers due to IPF alignment concerns.
|
|
|
|
Arguments:
|
|
|
|
FileName - File name of failing routine.
|
|
|
|
LineNumber - Line number of failing ASSERT().
|
|
|
|
Description - Description, usually the assertion,
|
|
|
|
BufferSize - Size of Buffer.
|
|
|
|
Buffer - Caller allocated buffer, contains ReportStatusCode extendecd data
|
|
|
|
Returns:
|
|
|
|
Status code
|
|
|
|
--*/
|
|
;
|
|
|
|
BOOLEAN
|
|
ReportStatusCodeExtractAssertInfo (
|
|
IN EFI_STATUS_CODE_TYPE CodeType,
|
|
IN EFI_STATUS_CODE_VALUE Value,
|
|
IN EFI_STATUS_CODE_DATA *Data,
|
|
OUT CHAR8 **Filename,
|
|
OUT CHAR8 **Description,
|
|
OUT UINT32 *LineNumber
|
|
)
|
|
/*++
|
|
|
|
Routine Description:
|
|
|
|
Extract assert information from status code data.
|
|
|
|
Arguments:
|
|
|
|
CodeType - Code type
|
|
Value - Code value
|
|
Data - Optional data associated with this status code.
|
|
Filename - Filename extracted from Data
|
|
Description - Description extracted from Data
|
|
LineNumber - Line number extracted from Data
|
|
|
|
Returns:
|
|
|
|
TRUE - Successfully extracted
|
|
|
|
FALSE - Extraction failed
|
|
|
|
--*/
|
|
;
|
|
|
|
BOOLEAN
|
|
ReportStatusCodeExtractDebugInfo (
|
|
IN EFI_STATUS_CODE_DATA *Data,
|
|
OUT UINT32 *ErrorLevel,
|
|
OUT VA_LIST *Marker,
|
|
OUT CHAR8 **Format
|
|
)
|
|
/*++
|
|
|
|
Routine Description:
|
|
|
|
Extract debug information from status code data.
|
|
|
|
Arguments:
|
|
|
|
Data - Optional data associated with status code.
|
|
ErrorLevel - Error level extracted from Data
|
|
Marker - VA_LIST extracted from Data
|
|
Format - Format string extracted from Data
|
|
|
|
Returns:
|
|
|
|
TRUE - Successfully extracted
|
|
|
|
FALSE - Extraction failed
|
|
|
|
--*/
|
|
;
|
|
|
|
BOOLEAN
|
|
CodeTypeToPostCode (
|
|
IN EFI_STATUS_CODE_TYPE CodeType,
|
|
IN EFI_STATUS_CODE_VALUE Value,
|
|
OUT UINT8 *PostCode
|
|
)
|
|
/*++
|
|
|
|
Routine Description:
|
|
|
|
Convert code value to an 8 bit post code
|
|
|
|
Arguments:
|
|
|
|
CodeType - Code type
|
|
Value - Code value
|
|
PostCode - Post code as output
|
|
|
|
Returns:
|
|
|
|
TRUE - Successfully converted
|
|
|
|
FALSE - Convertion failed
|
|
|
|
--*/
|
|
;
|
|
|
|
//
|
|
// math.c
|
|
//
|
|
UINT64
|
|
MultU64x32 (
|
|
IN UINT64 Multiplicand,
|
|
IN UINTN Multiplier
|
|
)
|
|
/*++
|
|
|
|
Routine Description:
|
|
|
|
This routine allows a 64 bit value to be multiplied with a 32 bit
|
|
value returns 64bit result.
|
|
No checking if the result is greater than 64bits
|
|
|
|
Arguments:
|
|
|
|
Multiplicand - multiplicand
|
|
Multiplier - multiplier
|
|
|
|
Returns:
|
|
|
|
Multiplicand * Multiplier
|
|
|
|
--*/
|
|
;
|
|
|
|
UINT64
|
|
DivU64x32 (
|
|
IN UINT64 Dividend,
|
|
IN UINTN Divisor,
|
|
OUT UINTN *Remainder OPTIONAL
|
|
)
|
|
/*++
|
|
|
|
Routine Description:
|
|
|
|
This routine allows a 64 bit value to be divided with a 32 bit value returns
|
|
64bit result and the Remainder.
|
|
|
|
Arguments:
|
|
|
|
Dividend - dividend
|
|
Divisor - divisor
|
|
Remainder - buffer for remainder
|
|
|
|
Returns:
|
|
|
|
Dividend / Divisor
|
|
Remainder = Dividend mod Divisor
|
|
|
|
--*/
|
|
;
|
|
|
|
UINT64
|
|
RShiftU64 (
|
|
IN UINT64 Operand,
|
|
IN UINTN Count
|
|
)
|
|
/*++
|
|
|
|
Routine Description:
|
|
|
|
This routine allows a 64 bit value to be right shifted by 32 bits and returns the
|
|
shifted value.
|
|
Count is valid up 63. (Only Bits 0-5 is valid for Count)
|
|
|
|
Arguments:
|
|
|
|
Operand - Value to be shifted
|
|
Count - Number of times to shift right.
|
|
|
|
Returns:
|
|
|
|
Value shifted right identified by the Count.
|
|
|
|
--*/
|
|
;
|
|
|
|
UINT64
|
|
LShiftU64 (
|
|
IN UINT64 Operand,
|
|
IN UINTN Count
|
|
)
|
|
/*++
|
|
|
|
Routine Description:
|
|
|
|
This routine allows a 64 bit value to be left shifted by 32 bits and
|
|
returns the shifted value.
|
|
Count is valid up 63. (Only Bits 0-5 is valid for Count)
|
|
|
|
Arguments:
|
|
|
|
Operand - Value to be shifted
|
|
Count - Number of times to shift left.
|
|
|
|
Returns:
|
|
|
|
Value shifted left identified by the Count.
|
|
|
|
--*/
|
|
;
|
|
|
|
UINT64
|
|
Power10U64 (
|
|
IN UINT64 Operand,
|
|
IN UINTN Power
|
|
)
|
|
/*++
|
|
|
|
Routine Description:
|
|
|
|
Raise 10 to the power of Power, and multiply the result with Operand
|
|
|
|
Arguments:
|
|
|
|
Operand - multiplicand
|
|
Power - power
|
|
|
|
Returns:
|
|
|
|
Operand * 10 ^ Power
|
|
|
|
--*/
|
|
;
|
|
|
|
UINT8
|
|
Log2 (
|
|
IN UINT64 Operand
|
|
)
|
|
/*++
|
|
|
|
Routine Description:
|
|
|
|
Calculates and floors logarithms based on 2
|
|
|
|
Arguments:
|
|
|
|
Operand - value to calculate logarithm
|
|
|
|
Returns:
|
|
|
|
The largest integer that is less than or equal
|
|
to the logarithm of Operand based on 2
|
|
|
|
--*/
|
|
;
|
|
|
|
UINT64
|
|
GetPowerOfTwo (
|
|
IN UINT64 Input
|
|
)
|
|
/*++
|
|
|
|
Routine Description:
|
|
|
|
Calculates the largest integer that is both
|
|
a power of two and less than Input
|
|
|
|
Arguments:
|
|
|
|
Input - value to calculate power of two
|
|
|
|
Returns:
|
|
|
|
the largest integer that is both a power of
|
|
two and less than Input
|
|
|
|
--*/
|
|
;
|
|
|
|
//
|
|
// Unicode String primatives
|
|
//
|
|
VOID
|
|
EfiStrCpy (
|
|
IN CHAR16 *Destination,
|
|
IN CHAR16 *Source
|
|
)
|
|
/*++
|
|
|
|
Routine Description:
|
|
Copy the Unicode string Source to Destination.
|
|
|
|
Arguments:
|
|
Destination - Location to copy string
|
|
Source - String to copy
|
|
|
|
Returns:
|
|
NONE
|
|
|
|
--*/
|
|
;
|
|
|
|
VOID
|
|
EfiStrnCpy (
|
|
OUT CHAR16 *Dst,
|
|
IN CHAR16 *Src,
|
|
IN UINTN Length
|
|
)
|
|
/*++
|
|
|
|
Routine Description:
|
|
Copy a string from source to destination
|
|
|
|
Arguments:
|
|
Dst Destination string
|
|
Src Source string
|
|
Length Length of destination string
|
|
|
|
Returns:
|
|
|
|
--*/
|
|
;
|
|
|
|
UINTN
|
|
EfiStrLen (
|
|
IN CHAR16 *String
|
|
)
|
|
/*++
|
|
|
|
Routine Description:
|
|
Return the number of Unicode characters in String. This is not the same as
|
|
the length of the string in bytes.
|
|
|
|
Arguments:
|
|
String - String to process
|
|
|
|
Returns:
|
|
Number of Unicode characters in String
|
|
|
|
--*/
|
|
;
|
|
|
|
UINTN
|
|
EfiStrSize (
|
|
IN CHAR16 *String
|
|
)
|
|
/*++
|
|
|
|
Routine Description:
|
|
Return the number bytes in the Unicode String. This is not the same as
|
|
the length of the string in characters. The string size includes the NULL
|
|
|
|
Arguments:
|
|
String - String to process
|
|
|
|
Returns:
|
|
Number of bytes in String
|
|
|
|
--*/
|
|
;
|
|
|
|
INTN
|
|
EfiStrCmp (
|
|
IN CHAR16 *String,
|
|
IN CHAR16 *String2
|
|
)
|
|
/*++
|
|
|
|
Routine Description:
|
|
Return the alphabetic relationship between two stirngs.
|
|
|
|
Arguments:
|
|
String - Compare to String2
|
|
|
|
String2 - Compare to String
|
|
|
|
Returns:
|
|
0 - Identical
|
|
|
|
> 0 - String is alphabeticly greater than String2
|
|
|
|
< 0 - String is alphabeticly less than String2
|
|
|
|
--*/
|
|
;
|
|
|
|
INTN
|
|
EfiStrnCmp (
|
|
IN CHAR16 *String,
|
|
IN CHAR16 *String2,
|
|
IN UINTN Length
|
|
)
|
|
/*++
|
|
|
|
Routine Description:
|
|
This function compares the Unicode string String to the Unicode
|
|
string String2 for len characters. If the first len characters
|
|
of String is identical to the first len characters of String2,
|
|
then 0 is returned. If substring of String sorts lexicographically
|
|
after String2, the function returns a number greater than 0. If
|
|
substring of String sorts lexicographically before String2, the
|
|
function returns a number less than 0.
|
|
|
|
Arguments:
|
|
String - Compare to String2
|
|
String2 - Compare to String
|
|
Length - Number of Unicode characters to compare
|
|
|
|
Returns:
|
|
0 - The substring of String and String2 is identical.
|
|
> 0 - The substring of String sorts lexicographically after String2
|
|
< 0 - The substring of String sorts lexicographically before String2
|
|
|
|
--*/
|
|
;
|
|
|
|
VOID
|
|
EfiStrCat (
|
|
IN CHAR16 *Destination,
|
|
IN CHAR16 *Source
|
|
)
|
|
/*++
|
|
|
|
Routine Description:
|
|
Concatinate Source on the end of Destination
|
|
|
|
Arguments:
|
|
Destination - String to added to the end of.
|
|
Source - String to concatinate.
|
|
|
|
Returns:
|
|
NONE
|
|
|
|
--*/
|
|
;
|
|
|
|
VOID
|
|
EfiStrnCat (
|
|
IN CHAR16 *Dest,
|
|
IN CHAR16 *Src,
|
|
IN UINTN Length
|
|
)
|
|
/*++
|
|
|
|
Routine Description:
|
|
Concatinate Source on the end of Destination
|
|
|
|
Arguments:
|
|
Dst Destination string
|
|
Src Source string
|
|
Length Length of destination string
|
|
|
|
Returns:
|
|
|
|
--*/
|
|
;
|
|
|
|
UINTN
|
|
EfiAsciiStrLen (
|
|
IN CHAR8 *String
|
|
)
|
|
/*++
|
|
|
|
Routine Description:
|
|
Return the number of Ascii characters in String. This is not the same as
|
|
the length of the string in bytes.
|
|
|
|
Arguments:
|
|
String - String to process
|
|
|
|
Returns:
|
|
Number of Unicode characters in String
|
|
|
|
--*/
|
|
;
|
|
|
|
CHAR8 *
|
|
EfiAsciiStrCpy (
|
|
IN CHAR8 *Destination,
|
|
IN CHAR8 *Source
|
|
)
|
|
/*++
|
|
|
|
Routine Description:
|
|
Copy the Ascii string Source to Destination.
|
|
|
|
Arguments:
|
|
Destination - Location to copy string
|
|
Source - String to copy
|
|
|
|
Returns:
|
|
Pointer just pass the end of Destination
|
|
|
|
--*/
|
|
;
|
|
|
|
VOID
|
|
EfiAsciiStrnCpy (
|
|
OUT CHAR8 *Dst,
|
|
IN CHAR8 *Src,
|
|
IN UINTN Length
|
|
)
|
|
/*++
|
|
|
|
Routine Description:
|
|
Copy the Ascii string from source to destination
|
|
|
|
Arguments:
|
|
Dst Destination string
|
|
Src Source string
|
|
Length Length of destination string
|
|
|
|
Returns:
|
|
|
|
--*/
|
|
;
|
|
|
|
UINTN
|
|
EfiAsciiStrSize (
|
|
IN CHAR8 *String
|
|
)
|
|
/*++
|
|
|
|
Routine Description:
|
|
Return the number bytes in the Ascii String. This is not the same as
|
|
the length of the string in characters. The string size includes the NULL
|
|
|
|
Arguments:
|
|
String - String to process
|
|
|
|
Returns:
|
|
Number of bytes in String
|
|
|
|
--*/
|
|
;
|
|
|
|
|
|
INTN
|
|
EfiAsciiStrCmp (
|
|
IN CHAR8 *String,
|
|
IN CHAR8 *String2
|
|
)
|
|
/*++
|
|
|
|
Routine Description:
|
|
Compare the Ascii string pointed by String to the string pointed by String2.
|
|
|
|
Arguments:
|
|
String - String to process
|
|
|
|
String2 - The other string to process
|
|
|
|
Returns:
|
|
Return a positive integer if String is lexicall greater than String2; Zero if
|
|
the two strings are identical; and a negative interger if String is lexically
|
|
less than String2.
|
|
--*/
|
|
;
|
|
|
|
INTN
|
|
EfiAsciiStrnCmp (
|
|
IN CHAR8 *String,
|
|
IN CHAR8 *String2,
|
|
IN UINTN Length
|
|
)
|
|
/*++
|
|
|
|
Routine Description:
|
|
This function compares the ASCII string String to the ASCII
|
|
string String2 for len characters. If the first len characters
|
|
of String is identical to the first len characters of String2,
|
|
then 0 is returned. If substring of String sorts lexicographically
|
|
after String2, the function returns a number greater than 0. If
|
|
substring of String sorts lexicographically before String2, the
|
|
function returns a number less than 0.
|
|
|
|
Arguments:
|
|
String - Compare to String2
|
|
String2 - Compare to String
|
|
Length - Number of ASCII characters to compare
|
|
|
|
Returns:
|
|
0 - The substring of String and String2 is identical.
|
|
> 0 - The substring of String sorts lexicographically after String2
|
|
< 0 - The substring of String sorts lexicographically before String2
|
|
|
|
--*/
|
|
;
|
|
|
|
VOID
|
|
EfiAsciiStrCat (
|
|
IN CHAR8 *Destination,
|
|
IN CHAR8 *Source
|
|
)
|
|
/*++
|
|
|
|
Routine Description:
|
|
Concatinate Source on the end of Destination
|
|
|
|
Arguments:
|
|
Destination - String to added to the end of.
|
|
Source - String to concatinate.
|
|
|
|
Returns:
|
|
NONE
|
|
|
|
--*/
|
|
;
|
|
|
|
VOID
|
|
EfiAsciiStrnCat (
|
|
IN CHAR8 *Destination,
|
|
IN CHAR8 *Source,
|
|
IN UINTN Length
|
|
)
|
|
/*++
|
|
|
|
Routine Description:
|
|
Concatinate Source on the end of Destination
|
|
|
|
Arguments:
|
|
Destination - String to added to the end of.
|
|
Source - String to concatinate.
|
|
|
|
Returns:
|
|
NONE
|
|
|
|
--*/
|
|
;
|
|
|
|
//
|
|
// Print primitives
|
|
//
|
|
#define LEFT_JUSTIFY 0x01
|
|
#define PREFIX_SIGN 0x02
|
|
#define PREFIX_BLANK 0x04
|
|
#define COMMA_TYPE 0x08
|
|
#define LONG_TYPE 0x10
|
|
#define PREFIX_ZERO 0x20
|
|
|
|
//
|
|
// Length of temp string buffer to store value string.
|
|
//
|
|
#define CHARACTER_NUMBER_FOR_VALUE 30
|
|
|
|
UINTN
|
|
EfiValueToHexStr (
|
|
IN OUT CHAR16 *Buffer,
|
|
IN UINT64 Value,
|
|
IN UINTN Flags,
|
|
IN UINTN Width
|
|
)
|
|
/*++
|
|
|
|
Routine Description:
|
|
|
|
VSPrint worker function that prints a Value as a hex number in Buffer
|
|
|
|
Arguments:
|
|
|
|
Buffer - Location to place ascii hex string of Value.
|
|
|
|
Value - Hex value to convert to a string in Buffer.
|
|
|
|
Flags - Flags to use in printing Hex string, see file header for details.
|
|
|
|
Width - Width of hex value.
|
|
|
|
Returns:
|
|
|
|
Number of characters printed.
|
|
|
|
--*/
|
|
;
|
|
|
|
UINTN
|
|
EfiValueToString (
|
|
IN OUT CHAR16 *Buffer,
|
|
IN INT64 Value,
|
|
IN UINTN Flags,
|
|
IN UINTN Width
|
|
)
|
|
/*++
|
|
|
|
Routine Description:
|
|
|
|
VSPrint worker function that prints a Value as a decimal number in Buffer
|
|
|
|
Arguments:
|
|
|
|
Buffer - Location to place ascii decimal number string of Value.
|
|
|
|
Value - Decimal value to convert to a string in Buffer.
|
|
|
|
Flags - Flags to use in printing decimal string, see file header for details.
|
|
|
|
Width - Width of hex value.
|
|
|
|
Returns:
|
|
|
|
Number of characters printed.
|
|
|
|
--*/
|
|
;
|
|
|
|
BOOLEAN
|
|
IsHexDigit (
|
|
OUT UINT8 *Digit,
|
|
IN CHAR16 Char
|
|
)
|
|
/*++
|
|
|
|
Routine Description:
|
|
Determines if a Unicode character is a hexadecimal digit.
|
|
The test is case insensitive.
|
|
|
|
Arguments:
|
|
Digit - Pointer to byte that receives the value of the hex character.
|
|
Char - Unicode character to test.
|
|
|
|
Returns:
|
|
TRUE - If the character is a hexadecimal digit.
|
|
FALSE - Otherwise.
|
|
|
|
--*/
|
|
;
|
|
|
|
CHAR16
|
|
NibbleToHexChar (
|
|
UINT8 Nibble
|
|
)
|
|
/*++
|
|
|
|
Routine Description:
|
|
Converts the low nibble of a byte to hex unicode character.
|
|
|
|
Arguments:
|
|
Nibble - lower nibble of a byte.
|
|
|
|
Returns:
|
|
Hex unicode character.
|
|
|
|
--*/
|
|
;
|
|
|
|
EFI_STATUS
|
|
HexStringToBuf (
|
|
IN OUT UINT8 *Buf,
|
|
IN OUT UINTN *Len,
|
|
IN CHAR16 *Str,
|
|
OUT UINTN *ConvertedStrLen OPTIONAL
|
|
)
|
|
/*++
|
|
|
|
Routine Description:
|
|
Converts Unicode string to binary buffer.
|
|
The conversion may be partial.
|
|
The first character in the string that is not hex digit stops the conversion.
|
|
At a minimum, any blob of data could be represented as a hex string.
|
|
|
|
Arguments:
|
|
Buf - Pointer to buffer that receives the data.
|
|
Len - Length in bytes of the buffer to hold converted data.
|
|
If routine return with EFI_SUCCESS, containing length of converted data.
|
|
If routine return with EFI_BUFFER_TOO_SMALL, containg length of buffer desired.
|
|
Str - String to be converted from.
|
|
ConvertedStrLen - Length of the Hex String consumed.
|
|
|
|
Returns:
|
|
EFI_SUCCESS: Routine Success.
|
|
EFI_BUFFER_TOO_SMALL: The buffer is too small to hold converted data.
|
|
EFI_
|
|
|
|
--*/
|
|
;
|
|
|
|
EFI_STATUS
|
|
BufToHexString (
|
|
IN OUT CHAR16 *Str,
|
|
IN OUT UINTN *HexStringBufferLength,
|
|
IN UINT8 *Buf,
|
|
IN UINTN Len
|
|
)
|
|
/*++
|
|
|
|
Routine Description:
|
|
Converts binary buffer to Unicode string.
|
|
At a minimum, any blob of data could be represented as a hex string.
|
|
|
|
Arguments:
|
|
Str - Pointer to the string.
|
|
HexStringBufferLength - Length in bytes of buffer to hold the hex string. Includes tailing '\0' character.
|
|
If routine return with EFI_SUCCESS, containing length of hex string buffer.
|
|
If routine return with EFI_BUFFER_TOO_SMALL, containg length of hex string buffer desired.
|
|
Buf - Buffer to be converted from.
|
|
Len - Length in bytes of the buffer to be converted.
|
|
|
|
Returns:
|
|
EFI_SUCCESS: Routine success.
|
|
EFI_BUFFER_TOO_SMALL: The hex string buffer is too small.
|
|
|
|
--*/
|
|
;
|
|
|
|
VOID
|
|
EfiStrTrim (
|
|
IN OUT CHAR16 *str,
|
|
IN CHAR16 CharC
|
|
)
|
|
/*++
|
|
|
|
Routine Description:
|
|
|
|
Removes (trims) specified leading and trailing characters from a string.
|
|
|
|
Arguments:
|
|
|
|
str - Pointer to the null-terminated string to be trimmed. On return,
|
|
str will hold the trimmed string.
|
|
CharC - Character will be trimmed from str.
|
|
|
|
Returns:
|
|
|
|
None
|
|
|
|
--*/
|
|
;
|
|
CHAR16*
|
|
EfiStrStr (
|
|
IN CHAR16 *String,
|
|
IN CHAR16 *StrCharSet
|
|
)
|
|
/*++
|
|
|
|
Routine Description:
|
|
|
|
Find a substring.
|
|
|
|
Arguments:
|
|
|
|
String - Null-terminated string to search.
|
|
StrCharSet - Null-terminated string to search for.
|
|
|
|
Returns:
|
|
The address of the first occurrence of the matching substring if successful, or NULL otherwise.
|
|
--*/
|
|
;
|
|
|
|
CHAR8*
|
|
EfiAsciiStrStr (
|
|
IN CHAR8 *String,
|
|
IN CHAR8 *StrCharSet
|
|
)
|
|
/*++
|
|
|
|
Routine Description:
|
|
|
|
Find a Ascii substring.
|
|
|
|
Arguments:
|
|
|
|
String - Null-terminated Ascii string to search.
|
|
StrCharSet - Null-terminated Ascii string to search for.
|
|
|
|
Returns:
|
|
The address of the first occurrence of the matching Ascii substring if successful, or NULL otherwise.
|
|
--*/
|
|
;
|
|
#endif
|