| /*++ | |
| Copyright (c) 2004 - 2012, 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 integer 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 |