-/** @file
- Print Library worker functions.
-
- Copyright (c) 2006 - 2007, Intel Corporation<BR>
- 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: PrintLibInternal.c
-
-**/
-
-#include "PrintLibInternal.h"
-
-GLOBAL_REMOVE_IF_UNREFERENCED CONST CHAR8 mHexStr[] = {'0','1','2','3','4','5','6','7','8','9','A','B','C','D','E','F'};
-
-
-/**
- Internal function that places the character into the Buffer.
-
- Internal function that places ASCII or Unicode character into the Buffer.
-
- @param Buffer Buffer to place the Unicode or ASCII string.
- @param EndBuffer The end of the input Buffer. No characters will be
- placed after that.
- @param Length Count of character to be placed into Buffer.
- @param Character Character to be placed into Buffer.
- @param Increment Character increment in Buffer.
-
- @return Number of characters printed.
-
-**/
-CHAR8 *
-BasePrintLibFillBuffer (
- CHAR8 *Buffer,
- CHAR8 *EndBuffer,
- INTN Length,
- UINTN Character,
- INTN Increment
- )
-{
- INTN Index;
-
- for (Index = 0; Index < Length && Buffer < EndBuffer; Index++) {
- *Buffer = (CHAR8) Character;
- *(Buffer + 1) = (CHAR8) (Character >> 8);
- Buffer += Increment;
- }
- return Buffer;
-}
-
-/**
- Internal function that convert a decimal number to a string in Buffer.
-
- Print worker function that convert a decimal number to a string in Buffer.
-
- @param Buffer Location to place the Unicode or ASCII string of Value.
- @param Value Value to convert to a Decimal or Hexidecimal string in Buffer.
- @param Radix Radix of the value
-
- @return Number of characters printed.
-
-**/
-UINTN
-EFIAPI
-BasePrintLibValueToString (
- IN OUT CHAR8 *Buffer,
- IN INT64 Value,
- IN UINTN Radix
- )
-{
- UINTN Digits;
- UINT32 Remainder;
-
- //
- // Loop to convert one digit at a time in reverse order
- //
- *(Buffer++) = 0;
- Digits = 0;
- do {
- Value = (INT64)DivU64x32Remainder ((UINT64)Value, (UINT32)Radix, &Remainder);
- *(Buffer++) = mHexStr[Remainder];
- Digits++;
- } while (Value != 0);
- return Digits;
-}
-
-/**
- Internal function that converts a decimal value to a Null-terminated string.
-
- Converts the decimal number specified by Value to a Null-terminated
- string specified by Buffer containing at most Width characters.
- If Width is 0 then a width of MAXIMUM_VALUE_CHARACTERS is assumed.
- The number of characters in Buffer is returned not including the Null-terminator.
- If the conversion contains more than Width characters, then only the first
- Width characters are returned, and the total number of characters
- required to perform the conversion is returned.
- Additional conversion parameters are specified in Flags.
- The Flags bit LEFT_JUSTIFY is always ignored.
- All conversions are left justified in Buffer.
- If Width is 0, PREFIX_ZERO is ignored in Flags.
- If COMMA_TYPE is set in Flags, then PREFIX_ZERO is ignored in Flags, and commas
- are inserted every 3rd digit starting from the right.
- If HEX_RADIX is set in Flags, then the output buffer will be formatted in hexadecimal format.
- If Value is < 0 and HEX_RADIX is not set in Flags, then the fist character in Buffer is a '-'.
- If PREFIX_ZERO is set in Flags and PREFIX_ZERO is not being ignored,
- then Buffer is padded with '0' characters so the combination of the optional '-'
- sign character, '0' characters, digit characters for Value, and the Null-terminator
- add up to Width characters.
- If both COMMA_TYPE and HEX_RADIX are set in Flags, then ASSERT().
-
- If Buffer is NULL, then ASSERT().
- If unsupported bits are set in Flags, then ASSERT().
- If Width >= MAXIMUM_VALUE_CHARACTERS, then ASSERT()
-
- @param Buffer Pointer to the output buffer for the produced Null-terminated
- string.
- @param Flags The bitmask of flags that specify left justification, zero pad,
- and commas.
- @param Value The 64-bit signed value to convert to a string.
- @param Width The maximum number of characters to place in Buffer, not including
- the Null-terminator.
- @param Increment Character increment in Buffer.
-
- @return The number of characters in Buffer not including the Null-terminator.
-
-**/
-UINTN
-BasePrintLibConvertValueToString (
- IN OUT CHAR8 *Buffer,
- IN UINTN Flags,
- IN INT64 Value,
- IN UINTN Width,
- IN UINTN Increment
- )
-{
- CHAR8 *OriginalBuffer;
- CHAR8 *EndBuffer;
- CHAR8 ValueBuffer[MAXIMUM_VALUE_CHARACTERS];
- UINTN Count;
- UINTN Digits;
- UINTN Index;
- UINTN Radix;
-
- ASSERT (Buffer != NULL);
- ASSERT (Width < MAXIMUM_VALUE_CHARACTERS);
- //
- // Make sure Flags can only contain supported bits.
- //
- ASSERT ((Flags & ~(LEFT_JUSTIFY | COMMA_TYPE | PREFIX_ZERO | RADIX_HEX)) == 0);
-
- //
- // If both COMMA_TYPE and HEX_RADIX are set, then ASSERT ()
- //
- ASSERT (((Flags & COMMA_TYPE) != 0 && (Flags & RADIX_HEX) != 0) == FALSE);
-
- OriginalBuffer = Buffer;
-
- if (Width == 0 || (Flags & COMMA_TYPE) != 0) {
- Flags &= (~PREFIX_ZERO);
- }
-
- if (Width == 0) {
- Width = MAXIMUM_VALUE_CHARACTERS - 1;
- }
- //
- // Set the tag for the end of the input Buffer.
- //
- EndBuffer = Buffer + Width * Increment;
-
- if ((Value < 0) && ((Flags & RADIX_HEX) == 0)) {
- Value = -Value;
- Buffer = BasePrintLibFillBuffer (Buffer, EndBuffer, 1, '-', Increment);
- Width--;
- }
-
- Radix = ((Flags & RADIX_HEX) == 0)? 10 : 16;
- Count = BasePrintLibValueToString (ValueBuffer, Value, Radix);
-
- if ((Flags & PREFIX_ZERO) != 0) {
- Buffer = BasePrintLibFillBuffer (Buffer, EndBuffer, Width - Count, '0', Increment);
- }
-
- Digits = Count % 3;
- if (Digits != 0) {
- Digits = 3 - Digits;
- }
- for (Index = 0; Index < Count; Index++) {
- Buffer = BasePrintLibFillBuffer (Buffer, EndBuffer, 1, ValueBuffer[Count - Index], Increment);
- if ((Flags & COMMA_TYPE) != 0) {
- Digits++;
- if (Digits == 3) {
- Digits = 0;
- if ((Index + 1) < Count) {
- Buffer = BasePrintLibFillBuffer (Buffer, EndBuffer, 1, ',', Increment);
- }
- }
- }
- }
-
- BasePrintLibFillBuffer (Buffer, EndBuffer + Increment, 1, 0, Increment);
-
- return ((Buffer - OriginalBuffer) / Increment);
-}
-
+/** @file\r
+ Print Library internal worker functions.\r
+\r
+ Copyright (c) 2006 - 2017, Intel Corporation. All rights reserved.<BR>\r
+ This program and the accompanying materials\r
+ are licensed and made available under the terms and conditions of the BSD License\r
+ which accompanies this distribution. The full text of the license may be found at\r
+ http://opensource.org/licenses/bsd-license.php.\r
+\r
+ THE PROGRAM IS DISTRIBUTED UNDER THE BSD LICENSE ON AN "AS IS" BASIS,\r
+ WITHOUT WARRANTIES OR REPRESENTATIONS OF ANY KIND, EITHER EXPRESS OR IMPLIED.\r
+\r
+**/\r
+\r
+#include "PrintLibInternal.h"\r
+\r
+#define WARNING_STATUS_NUMBER 5\r
+#define ERROR_STATUS_NUMBER 33\r
+\r
+//\r
+// Safe print checks\r
+//\r
+#define RSIZE_MAX (PcdGet32 (PcdMaximumUnicodeStringLength))\r
+#define ASCII_RSIZE_MAX (PcdGet32 (PcdMaximumAsciiStringLength))\r
+\r
+#define SAFE_PRINT_CONSTRAINT_CHECK(Expression, RetVal) \\r
+ do { \\r
+ ASSERT (Expression); \\r
+ if (!(Expression)) { \\r
+ return RetVal; \\r
+ } \\r
+ } while (FALSE)\r
+\r
+GLOBAL_REMOVE_IF_UNREFERENCED CONST CHAR8 mHexStr[] = {'0','1','2','3','4','5','6','7','8','9','A','B','C','D','E','F'};\r
+\r
+GLOBAL_REMOVE_IF_UNREFERENCED CONST CHAR8 * CONST mStatusString[] = {\r
+ "Success", // RETURN_SUCCESS = 0\r
+ "Warning Unknown Glyph", // RETURN_WARN_UNKNOWN_GLYPH = 1\r
+ "Warning Delete Failure", // RETURN_WARN_DELETE_FAILURE = 2\r
+ "Warning Write Failure", // RETURN_WARN_WRITE_FAILURE = 3\r
+ "Warning Buffer Too Small", // RETURN_WARN_BUFFER_TOO_SMALL = 4\r
+ "Warning Stale Data", // RETURN_WARN_STALE_DATA = 5\r
+ "Load Error", // RETURN_LOAD_ERROR = 1 | MAX_BIT\r
+ "Invalid Parameter", // RETURN_INVALID_PARAMETER = 2 | MAX_BIT\r
+ "Unsupported", // RETURN_UNSUPPORTED = 3 | MAX_BIT\r
+ "Bad Buffer Size", // RETURN_BAD_BUFFER_SIZE = 4 | MAX_BIT\r
+ "Buffer Too Small", // RETURN_BUFFER_TOO_SMALL, = 5 | MAX_BIT\r
+ "Not Ready", // RETURN_NOT_READY = 6 | MAX_BIT\r
+ "Device Error", // RETURN_DEVICE_ERROR = 7 | MAX_BIT\r
+ "Write Protected", // RETURN_WRITE_PROTECTED = 8 | MAX_BIT\r
+ "Out of Resources", // RETURN_OUT_OF_RESOURCES = 9 | MAX_BIT\r
+ "Volume Corrupt", // RETURN_VOLUME_CORRUPTED = 10 | MAX_BIT\r
+ "Volume Full", // RETURN_VOLUME_FULL = 11 | MAX_BIT\r
+ "No Media", // RETURN_NO_MEDIA = 12 | MAX_BIT\r
+ "Media changed", // RETURN_MEDIA_CHANGED = 13 | MAX_BIT\r
+ "Not Found", // RETURN_NOT_FOUND = 14 | MAX_BIT\r
+ "Access Denied", // RETURN_ACCESS_DENIED = 15 | MAX_BIT\r
+ "No Response", // RETURN_NO_RESPONSE = 16 | MAX_BIT\r
+ "No mapping", // RETURN_NO_MAPPING = 17 | MAX_BIT\r
+ "Time out", // RETURN_TIMEOUT = 18 | MAX_BIT\r
+ "Not started", // RETURN_NOT_STARTED = 19 | MAX_BIT\r
+ "Already started", // RETURN_ALREADY_STARTED = 20 | MAX_BIT\r
+ "Aborted", // RETURN_ABORTED = 21 | MAX_BIT\r
+ "ICMP Error", // RETURN_ICMP_ERROR = 22 | MAX_BIT\r
+ "TFTP Error", // RETURN_TFTP_ERROR = 23 | MAX_BIT\r
+ "Protocol Error", // RETURN_PROTOCOL_ERROR = 24 | MAX_BIT\r
+ "Incompatible Version", // RETURN_INCOMPATIBLE_VERSION = 25 | MAX_BIT\r
+ "Security Violation", // RETURN_SECURITY_VIOLATION = 26 | MAX_BIT\r
+ "CRC Error", // RETURN_CRC_ERROR = 27 | MAX_BIT\r
+ "End of Media", // RETURN_END_OF_MEDIA = 28 | MAX_BIT\r
+ "Reserved (29)", // RESERVED = 29 | MAX_BIT\r
+ "Reserved (30)", // RESERVED = 30 | MAX_BIT\r
+ "End of File", // RETURN_END_OF_FILE = 31 | MAX_BIT\r
+ "Invalid Language", // RETURN_INVALID_LANGUAGE = 32 | MAX_BIT\r
+ "Compromised Data" // RETURN_COMPROMISED_DATA = 33 | MAX_BIT\r
+};\r
+\r
+\r
+/**\r
+ Internal function that places the character into the Buffer.\r
+\r
+ Internal function that places ASCII or Unicode character into the Buffer.\r
+\r
+ @param Buffer The buffer to place the Unicode or ASCII string.\r
+ @param EndBuffer The end of the input Buffer. No characters will be\r
+ placed after that. \r
+ @param Length The count of character to be placed into Buffer.\r
+ (Negative value indicates no buffer fill.)\r
+ @param Character The character to be placed into Buffer.\r
+ @param Increment The character increment in Buffer.\r
+\r
+ @return Buffer.\r
+\r
+**/\r
+CHAR8 *\r
+BasePrintLibFillBuffer (\r
+ OUT CHAR8 *Buffer,\r
+ IN CHAR8 *EndBuffer,\r
+ IN INTN Length,\r
+ IN UINTN Character,\r
+ IN INTN Increment\r
+ )\r
+{\r
+ INTN Index;\r
+ \r
+ for (Index = 0; Index < Length && Buffer < EndBuffer; Index++) {\r
+ *Buffer = (CHAR8) Character;\r
+ if (Increment != 1) {\r
+ *(Buffer + 1) = (CHAR8)(Character >> 8);\r
+ }\r
+ Buffer += Increment;\r
+ }\r
+\r
+ return Buffer;\r
+}\r
+\r
+/**\r
+ Internal function that convert a number to a string in Buffer.\r
+\r
+ Print worker function that converts a decimal or hexadecimal number to an ASCII string in Buffer.\r
+\r
+ @param Buffer Location to place the ASCII string of Value.\r
+ @param Value The value to convert to a Decimal or Hexadecimal string in Buffer.\r
+ @param Radix Radix of the value\r
+\r
+ @return A pointer to the end of buffer filled with ASCII string.\r
+\r
+**/\r
+CHAR8 *\r
+BasePrintLibValueToString (\r
+ IN OUT CHAR8 *Buffer, \r
+ IN INT64 Value, \r
+ IN UINTN Radix\r
+ )\r
+{\r
+ UINT32 Remainder;\r
+\r
+ //\r
+ // Loop to convert one digit at a time in reverse order\r
+ //\r
+ *Buffer = 0;\r
+ do {\r
+ Value = (INT64)DivU64x32Remainder ((UINT64)Value, (UINT32)Radix, &Remainder);\r
+ *(++Buffer) = mHexStr[Remainder];\r
+ } while (Value != 0);\r
+\r
+ //\r
+ // Return pointer of the end of filled buffer.\r
+ //\r
+ return Buffer;\r
+}\r
+\r
+/**\r
+ Internal function that converts a decimal value to a Null-terminated string.\r
+ \r
+ Converts the decimal number specified by Value to a Null-terminated \r
+ string specified by Buffer containing at most Width characters.\r
+ If Width is 0 then a width of MAXIMUM_VALUE_CHARACTERS is assumed.\r
+ The total number of characters placed in Buffer is returned.\r
+ If the conversion contains more than Width characters, then only the first\r
+ Width characters are returned, and the total number of characters \r
+ required to perform the conversion is returned.\r
+ Additional conversion parameters are specified in Flags. \r
+ The Flags bit LEFT_JUSTIFY is always ignored.\r
+ All conversions are left justified in Buffer.\r
+ If Width is 0, PREFIX_ZERO is ignored in Flags.\r
+ If COMMA_TYPE is set in Flags, then PREFIX_ZERO is ignored in Flags, and commas\r
+ are inserted every 3rd digit starting from the right.\r
+ If Value is < 0, then the fist character in Buffer is a '-'.\r
+ If PREFIX_ZERO is set in Flags and PREFIX_ZERO is not being ignored, \r
+ then Buffer is padded with '0' characters so the combination of the optional '-' \r
+ sign character, '0' characters, digit characters for Value, and the Null-terminator\r
+ add up to Width characters.\r
+\r
+ If Buffer is NULL, then ASSERT().\r
+ If unsupported bits are set in Flags, then ASSERT().\r
+ If Width >= MAXIMUM_VALUE_CHARACTERS, then ASSERT()\r
+\r
+ @param Buffer The pointer to the output buffer for the produced Null-terminated\r
+ string.\r
+ @param Flags The bitmask of flags that specify left justification, zero pad,\r
+ and commas.\r
+ @param Value The 64-bit signed value to convert to a string.\r
+ @param Width The maximum number of characters to place in Buffer, not including\r
+ the Null-terminator.\r
+ @param Increment The character increment in Buffer.\r
+ \r
+ @return Total number of characters required to perform the conversion.\r
+\r
+**/\r
+UINTN\r
+BasePrintLibConvertValueToString (\r
+ IN OUT CHAR8 *Buffer,\r
+ IN UINTN Flags,\r
+ IN INT64 Value,\r
+ IN UINTN Width,\r
+ IN UINTN Increment\r
+ )\r
+{\r
+ CHAR8 *OriginalBuffer;\r
+ CHAR8 *EndBuffer;\r
+ CHAR8 ValueBuffer[MAXIMUM_VALUE_CHARACTERS];\r
+ CHAR8 *ValueBufferPtr;\r
+ UINTN Count;\r
+ UINTN Digits;\r
+ UINTN Index;\r
+ UINTN Radix;\r
+\r
+ //\r
+ // Make sure Buffer is not NULL and Width < MAXIMUM\r
+ //\r
+ ASSERT (Buffer != NULL);\r
+ ASSERT (Width < MAXIMUM_VALUE_CHARACTERS);\r
+ //\r
+ // Make sure Flags can only contain supported bits.\r
+ //\r
+ ASSERT ((Flags & ~(LEFT_JUSTIFY | COMMA_TYPE | PREFIX_ZERO | RADIX_HEX)) == 0);\r
+\r
+ //\r
+ // If both COMMA_TYPE and RADIX_HEX are set, then ASSERT ()\r
+ //\r
+ ASSERT (((Flags & COMMA_TYPE) == 0) || ((Flags & RADIX_HEX) == 0));\r
+\r
+ OriginalBuffer = Buffer;\r
+ \r
+ //\r
+ // Width is 0 or COMMA_TYPE is set, PREFIX_ZERO is ignored.\r
+ //\r
+ if (Width == 0 || (Flags & COMMA_TYPE) != 0) {\r
+ Flags &= ~((UINTN) PREFIX_ZERO);\r
+ }\r
+ //\r
+ // If Width is 0 then a width of MAXIMUM_VALUE_CHARACTERS is assumed.\r
+ //\r
+ if (Width == 0) {\r
+ Width = MAXIMUM_VALUE_CHARACTERS - 1;\r
+ }\r
+ //\r
+ // Set the tag for the end of the input Buffer.\r
+ //\r
+ EndBuffer = Buffer + Width * Increment;\r
+ \r
+ //\r
+ // Convert decimal negative\r
+ //\r
+ if ((Value < 0) && ((Flags & RADIX_HEX) == 0)) {\r
+ Value = -Value;\r
+ Buffer = BasePrintLibFillBuffer (Buffer, EndBuffer, 1, '-', Increment);\r
+ Width--;\r
+ }\r
+ \r
+ //\r
+ // Count the length of the value string.\r
+ //\r
+ Radix = ((Flags & RADIX_HEX) == 0)? 10 : 16;\r
+ ValueBufferPtr = BasePrintLibValueToString (ValueBuffer, Value, Radix);\r
+ Count = ValueBufferPtr - ValueBuffer;\r
+ \r
+ //\r
+ // Append Zero\r
+ //\r
+ if ((Flags & PREFIX_ZERO) != 0) {\r
+ Buffer = BasePrintLibFillBuffer (Buffer, EndBuffer, Width - Count, '0', Increment);\r
+ }\r
+ \r
+ //\r
+ // Print Comma type for every 3 characters\r
+ //\r
+ Digits = Count % 3;\r
+ if (Digits != 0) {\r
+ Digits = 3 - Digits;\r
+ }\r
+ for (Index = 0; Index < Count; Index++) {\r
+ Buffer = BasePrintLibFillBuffer (Buffer, EndBuffer, 1, *ValueBufferPtr--, Increment);\r
+ if ((Flags & COMMA_TYPE) != 0) {\r
+ Digits++;\r
+ if (Digits == 3) {\r
+ Digits = 0;\r
+ if ((Index + 1) < Count) {\r
+ Buffer = BasePrintLibFillBuffer (Buffer, EndBuffer, 1, ',', Increment);\r
+ }\r
+ }\r
+ }\r
+ }\r
+ \r
+ //\r
+ // Print Null-terminator\r
+ //\r
+ BasePrintLibFillBuffer (Buffer, EndBuffer + Increment, 1, 0, Increment);\r
+\r
+ return ((Buffer - OriginalBuffer) / Increment);\r
+}\r
+\r
+/**\r
+ Internal function that converts a decimal value to a Null-terminated string.\r
+\r
+ Converts the decimal number specified by Value to a Null-terminated string\r
+ specified by Buffer containing at most Width characters. If Width is 0 then a\r
+ width of MAXIMUM_VALUE_CHARACTERS is assumed. If the conversion contains more\r
+ than Width characters, then only the first Width characters are placed in\r
+ Buffer. Additional conversion parameters are specified in Flags.\r
+ The Flags bit LEFT_JUSTIFY is always ignored.\r
+ All conversions are left justified in Buffer.\r
+ If Width is 0, PREFIX_ZERO is ignored in Flags.\r
+ If COMMA_TYPE is set in Flags, then PREFIX_ZERO is ignored in Flags, and\r
+ commas are inserted every 3rd digit starting from the right.\r
+ If Value is < 0, then the fist character in Buffer is a '-'.\r
+ If PREFIX_ZERO is set in Flags and PREFIX_ZERO is not being ignored,\r
+ then Buffer is padded with '0' characters so the combination of the optional\r
+ '-' sign character, '0' characters, digit characters for Value, and the\r
+ Null-terminator add up to Width characters.\r
+\r
+ If an error would be returned, the function will ASSERT().\r
+\r
+ @param Buffer The pointer to the output buffer for the produced\r
+ Null-terminated string.\r
+ @param BufferSize The size of Buffer in bytes, including the\r
+ Null-terminator.\r
+ @param Flags The bitmask of flags that specify left justification,\r
+ zero pad, and commas.\r
+ @param Value The 64-bit signed value to convert to a string.\r
+ @param Width The maximum number of characters to place in Buffer,\r
+ not including the Null-terminator.\r
+ @param Increment The character increment in Buffer.\r
+\r
+ @retval RETURN_SUCCESS The decimal value is converted.\r
+ @retval RETURN_BUFFER_TOO_SMALL If BufferSize cannot hold the converted\r
+ value.\r
+ @retval RETURN_INVALID_PARAMETER If Buffer is NULL.\r
+ If Increment is 1 and\r
+ PcdMaximumAsciiStringLength is not zero,\r
+ BufferSize is greater than\r
+ PcdMaximumAsciiStringLength.\r
+ If Increment is not 1 and\r
+ PcdMaximumUnicodeStringLength is not zero,\r
+ BufferSize is greater than\r
+ (PcdMaximumUnicodeStringLength *\r
+ sizeof (CHAR16) + 1).\r
+ If unsupported bits are set in Flags.\r
+ If both COMMA_TYPE and RADIX_HEX are set in\r
+ Flags.\r
+ If Width >= MAXIMUM_VALUE_CHARACTERS.\r
+\r
+**/\r
+RETURN_STATUS\r
+BasePrintLibConvertValueToStringS (\r
+ IN OUT CHAR8 *Buffer,\r
+ IN UINTN BufferSize,\r
+ IN UINTN Flags,\r
+ IN INT64 Value,\r
+ IN UINTN Width,\r
+ IN UINTN Increment\r
+ )\r
+{\r
+ CHAR8 *EndBuffer;\r
+ CHAR8 ValueBuffer[MAXIMUM_VALUE_CHARACTERS];\r
+ CHAR8 *ValueBufferPtr;\r
+ UINTN Count;\r
+ UINTN Digits;\r
+ UINTN Index;\r
+ UINTN Radix;\r
+\r
+ //\r
+ // 1. Buffer shall not be a null pointer.\r
+ //\r
+ SAFE_PRINT_CONSTRAINT_CHECK ((Buffer != NULL), RETURN_INVALID_PARAMETER);\r
+\r
+ //\r
+ // 2. BufferSize shall not be greater than (RSIZE_MAX * sizeof (CHAR16)) for\r
+ // Unicode output string or shall not be greater than ASCII_RSIZE_MAX for\r
+ // Ascii output string.\r
+ //\r
+ if (Increment == 1) {\r
+ //\r
+ // Ascii output string\r
+ //\r
+ if (ASCII_RSIZE_MAX != 0) {\r
+ SAFE_PRINT_CONSTRAINT_CHECK ((BufferSize <= ASCII_RSIZE_MAX), RETURN_INVALID_PARAMETER);\r
+ }\r
+ } else {\r
+ //\r
+ // Unicode output string\r
+ //\r
+ if (RSIZE_MAX != 0) {\r
+ SAFE_PRINT_CONSTRAINT_CHECK ((BufferSize <= RSIZE_MAX * sizeof (CHAR16) + 1), RETURN_INVALID_PARAMETER);\r
+ }\r
+ }\r
+\r
+ //\r
+ // 3. Flags shall be set properly.\r
+ //\r
+ SAFE_PRINT_CONSTRAINT_CHECK (((Flags & ~(LEFT_JUSTIFY | COMMA_TYPE | PREFIX_ZERO | RADIX_HEX)) == 0), RETURN_INVALID_PARAMETER);\r
+ SAFE_PRINT_CONSTRAINT_CHECK ((((Flags & COMMA_TYPE) == 0) || ((Flags & RADIX_HEX) == 0)), RETURN_INVALID_PARAMETER);\r
+\r
+ //\r
+ // 4. Width shall be smaller than MAXIMUM_VALUE_CHARACTERS.\r
+ //\r
+ SAFE_PRINT_CONSTRAINT_CHECK ((Width < MAXIMUM_VALUE_CHARACTERS), RETURN_INVALID_PARAMETER);\r
+\r
+ //\r
+ // Width is 0 or COMMA_TYPE is set, PREFIX_ZERO is ignored.\r
+ //\r
+ if (Width == 0 || (Flags & COMMA_TYPE) != 0) {\r
+ Flags &= ~((UINTN) PREFIX_ZERO);\r
+ }\r
+ //\r
+ // If Width is 0 then a width of MAXIMUM_VALUE_CHARACTERS is assumed.\r
+ //\r
+ if (Width == 0) {\r
+ Width = MAXIMUM_VALUE_CHARACTERS - 1;\r
+ }\r
+\r
+ //\r
+ // Count the characters of the output string.\r
+ //\r
+ Count = 0;\r
+ Radix = ((Flags & RADIX_HEX) == 0)? 10 : 16;\r
+\r
+ if ((Flags & PREFIX_ZERO) != 0) {\r
+ Count = Width;\r
+ } else {\r
+ if ((Value < 0) && ((Flags & RADIX_HEX) == 0)) {\r
+ Count++; // minus sign\r
+ ValueBufferPtr = BasePrintLibValueToString (ValueBuffer, -Value, Radix);\r
+ } else {\r
+ ValueBufferPtr = BasePrintLibValueToString (ValueBuffer, Value, Radix);\r
+ }\r
+ Digits = ValueBufferPtr - ValueBuffer;\r
+ Count += Digits;\r
+\r
+ if ((Flags & COMMA_TYPE) != 0) {\r
+ Count += (Digits - 1) / 3; // commas\r
+ }\r
+ }\r
+\r
+ Width = MIN (Count, Width);\r
+\r
+ //\r
+ // 5. BufferSize shall be large enough to hold the converted string.\r
+ //\r
+ SAFE_PRINT_CONSTRAINT_CHECK ((BufferSize >= (Width + 1) * Increment), RETURN_BUFFER_TOO_SMALL);\r
+\r
+ //\r
+ // Set the tag for the end of the input Buffer.\r
+ //\r
+ EndBuffer = Buffer + Width * Increment;\r
+\r
+ //\r
+ // Convert decimal negative\r
+ //\r
+ if ((Value < 0) && ((Flags & RADIX_HEX) == 0)) {\r
+ Value = -Value;\r
+ Buffer = BasePrintLibFillBuffer (Buffer, EndBuffer, 1, '-', Increment);\r
+ Width--;\r
+ }\r
+\r
+ //\r
+ // Count the length of the value string.\r
+ //\r
+ ValueBufferPtr = BasePrintLibValueToString (ValueBuffer, Value, Radix);\r
+ Count = ValueBufferPtr - ValueBuffer;\r
+\r
+ //\r
+ // Append Zero\r
+ //\r
+ if ((Flags & PREFIX_ZERO) != 0) {\r
+ Buffer = BasePrintLibFillBuffer (Buffer, EndBuffer, Width - Count, '0', Increment);\r
+ }\r
+\r
+ //\r
+ // Print Comma type for every 3 characters\r
+ //\r
+ Digits = Count % 3;\r
+ if (Digits != 0) {\r
+ Digits = 3 - Digits;\r
+ }\r
+ for (Index = 0; Index < Count; Index++) {\r
+ Buffer = BasePrintLibFillBuffer (Buffer, EndBuffer, 1, *ValueBufferPtr--, Increment);\r
+ if ((Flags & COMMA_TYPE) != 0) {\r
+ Digits++;\r
+ if (Digits == 3) {\r
+ Digits = 0;\r
+ if ((Index + 1) < Count) {\r
+ Buffer = BasePrintLibFillBuffer (Buffer, EndBuffer, 1, ',', Increment);\r
+ }\r
+ }\r
+ }\r
+ }\r
+\r
+ //\r
+ // Print Null-terminator\r
+ //\r
+ BasePrintLibFillBuffer (Buffer, EndBuffer + Increment, 1, 0, Increment);\r
+\r
+ return RETURN_SUCCESS;\r
+}\r
+\r
+/**\r
+ Worker function that produces a Null-terminated string in an output buffer \r
+ based on a Null-terminated format string and a VA_LIST argument list.\r
+\r
+ VSPrint function to process format and place the results in Buffer. Since a \r
+ VA_LIST is used this routine allows the nesting of Vararg routines. Thus \r
+ this is the main print working routine.\r
+\r
+ If COUNT_ONLY_NO_PRINT is set in Flags, Buffer will not be modified at all.\r
+\r
+ @param[out] Buffer The character buffer to print the results of the \r
+ parsing of Format into.\r
+ @param[in] BufferSize The maximum number of characters to put into \r
+ buffer.\r
+ @param[in] Flags Initial flags value.\r
+ Can only have FORMAT_UNICODE, OUTPUT_UNICODE, \r
+ and COUNT_ONLY_NO_PRINT set.\r
+ @param[in] Format A Null-terminated format string.\r
+ @param[in] VaListMarker VA_LIST style variable argument list consumed by\r
+ processing Format.\r
+ @param[in] BaseListMarker BASE_LIST style variable argument list consumed\r
+ by processing Format.\r
+\r
+ @return The number of characters printed not including the Null-terminator.\r
+ If COUNT_ONLY_NO_PRINT was set returns the same, but without any\r
+ modification to Buffer.\r
+\r
+**/\r
+UINTN\r
+BasePrintLibSPrintMarker (\r
+ OUT CHAR8 *Buffer,\r
+ IN UINTN BufferSize,\r
+ IN UINTN Flags,\r
+ IN CONST CHAR8 *Format,\r
+ IN VA_LIST VaListMarker, OPTIONAL\r
+ IN BASE_LIST BaseListMarker OPTIONAL\r
+ )\r
+{\r
+ CHAR8 *OriginalBuffer;\r
+ CHAR8 *EndBuffer;\r
+ CHAR8 ValueBuffer[MAXIMUM_VALUE_CHARACTERS];\r
+ UINT32 BytesPerOutputCharacter;\r
+ UINTN BytesPerFormatCharacter;\r
+ UINTN FormatMask;\r
+ UINTN FormatCharacter;\r
+ UINTN Width;\r
+ UINTN Precision;\r
+ INT64 Value;\r
+ CONST CHAR8 *ArgumentString;\r
+ UINTN Character;\r
+ GUID *TmpGuid;\r
+ TIME *TmpTime;\r
+ UINTN Count;\r
+ UINTN ArgumentMask;\r
+ INTN BytesPerArgumentCharacter;\r
+ UINTN ArgumentCharacter;\r
+ BOOLEAN Done;\r
+ UINTN Index;\r
+ CHAR8 Prefix;\r
+ BOOLEAN ZeroPad;\r
+ BOOLEAN Comma;\r
+ UINTN Digits;\r
+ UINTN Radix;\r
+ RETURN_STATUS Status;\r
+ UINT32 GuidData1;\r
+ UINT16 GuidData2;\r
+ UINT16 GuidData3;\r
+ UINTN LengthToReturn;\r
+\r
+ //\r
+ // If you change this code be sure to match the 2 versions of this function.\r
+ // Nearly identical logic is found in the BasePrintLib and \r
+ // DxePrintLibPrint2Protocol (both PrintLib instances).\r
+ //\r
+\r
+ //\r
+ // 1. Buffer shall not be a null pointer when both BufferSize > 0 and\r
+ // COUNT_ONLY_NO_PRINT is not set in Flags.\r
+ //\r
+ if ((BufferSize > 0) && ((Flags & COUNT_ONLY_NO_PRINT) == 0)) {\r
+ SAFE_PRINT_CONSTRAINT_CHECK ((Buffer != NULL), 0);\r
+ }\r
+\r
+ //\r
+ // 2. Format shall not be a null pointer when BufferSize > 0 or when\r
+ // COUNT_ONLY_NO_PRINT is set in Flags.\r
+ //\r
+ if ((BufferSize > 0) || ((Flags & COUNT_ONLY_NO_PRINT) != 0)) {\r
+ SAFE_PRINT_CONSTRAINT_CHECK ((Format != NULL), 0);\r
+ }\r
+\r
+ //\r
+ // 3. BufferSize shall not be greater than RSIZE_MAX for Unicode output or\r
+ // ASCII_RSIZE_MAX for Ascii output.\r
+ //\r
+ if ((Flags & OUTPUT_UNICODE) != 0) {\r
+ if (RSIZE_MAX != 0) {\r
+ SAFE_PRINT_CONSTRAINT_CHECK ((BufferSize <= RSIZE_MAX), 0);\r
+ }\r
+ BytesPerOutputCharacter = 2;\r
+ } else {\r
+ if (ASCII_RSIZE_MAX != 0) {\r
+ SAFE_PRINT_CONSTRAINT_CHECK ((BufferSize <= ASCII_RSIZE_MAX), 0);\r
+ }\r
+ BytesPerOutputCharacter = 1;\r
+ }\r
+\r
+ //\r
+ // 4. Format shall not contain more than RSIZE_MAX Unicode characters or\r
+ // ASCII_RSIZE_MAX Ascii characters.\r
+ //\r
+ if ((Flags & FORMAT_UNICODE) != 0) {\r
+ if (RSIZE_MAX != 0) {\r
+ SAFE_PRINT_CONSTRAINT_CHECK ((StrnLenS ((CHAR16 *)Format, RSIZE_MAX + 1) <= RSIZE_MAX), 0);\r
+ }\r
+ BytesPerFormatCharacter = 2;\r
+ FormatMask = 0xffff;\r
+ } else {\r
+ if (ASCII_RSIZE_MAX != 0) {\r
+ SAFE_PRINT_CONSTRAINT_CHECK ((AsciiStrnLenS (Format, ASCII_RSIZE_MAX + 1) <= ASCII_RSIZE_MAX), 0);\r
+ }\r
+ BytesPerFormatCharacter = 1;\r
+ FormatMask = 0xff;\r
+ }\r
+\r
+ if ((Flags & COUNT_ONLY_NO_PRINT) != 0) {\r
+ if (BufferSize == 0) {\r
+ Buffer = NULL;\r
+ }\r
+ } else {\r
+ //\r
+ // We can run without a Buffer for counting only.\r
+ //\r
+ if (BufferSize == 0) {\r
+ return 0;\r
+ }\r
+ }\r
+\r
+ LengthToReturn = 0;\r
+ EndBuffer = NULL;\r
+ OriginalBuffer = NULL;\r
+\r
+ //\r
+ // Reserve space for the Null terminator.\r
+ //\r
+ if (Buffer != NULL) {\r
+ BufferSize--;\r
+ OriginalBuffer = Buffer;\r
+\r
+ //\r
+ // Set the tag for the end of the input Buffer.\r
+ //\r
+ EndBuffer = Buffer + BufferSize * BytesPerOutputCharacter;\r
+ }\r
+\r
+ //\r
+ // Get the first character from the format string\r
+ //\r
+ FormatCharacter = ((*Format & 0xff) | (*(Format + 1) << 8)) & FormatMask;\r
+\r
+ //\r
+ // Loop until the end of the format string is reached or the output buffer is full\r
+ //\r
+ while (FormatCharacter != 0) {\r
+ if ((Buffer != NULL) && (Buffer >= EndBuffer)) {\r
+ break;\r
+ }\r
+ //\r
+ // Clear all the flag bits except those that may have been passed in\r
+ //\r
+ Flags &= (UINTN) (OUTPUT_UNICODE | FORMAT_UNICODE | COUNT_ONLY_NO_PRINT);\r
+\r
+ //\r
+ // Set the default width to zero, and the default precision to 1\r
+ //\r
+ Width = 0;\r
+ Precision = 1;\r
+ Prefix = 0;\r
+ Comma = FALSE;\r
+ ZeroPad = FALSE;\r
+ Count = 0;\r
+ Digits = 0;\r
+\r
+ switch (FormatCharacter) {\r
+ case '%':\r
+ //\r
+ // Parse Flags and Width\r
+ //\r
+ for (Done = FALSE; !Done; ) {\r
+ Format += BytesPerFormatCharacter;\r
+ FormatCharacter = ((*Format & 0xff) | (*(Format + 1) << 8)) & FormatMask;\r
+ switch (FormatCharacter) {\r
+ case '.': \r
+ Flags |= PRECISION; \r
+ break;\r
+ case '-': \r
+ Flags |= LEFT_JUSTIFY; \r
+ break;\r
+ case '+': \r
+ Flags |= PREFIX_SIGN; \r
+ break;\r
+ case ' ': \r
+ Flags |= PREFIX_BLANK; \r
+ break;\r
+ case ',': \r
+ Flags |= COMMA_TYPE; \r
+ break;\r
+ case 'L':\r
+ case 'l': \r
+ Flags |= LONG_TYPE; \r
+ break;\r
+ case '*':\r
+ if ((Flags & PRECISION) == 0) {\r
+ Flags |= PAD_TO_WIDTH;\r
+ if (BaseListMarker == NULL) {\r
+ Width = VA_ARG (VaListMarker, UINTN);\r
+ } else {\r
+ Width = BASE_ARG (BaseListMarker, UINTN);\r
+ }\r
+ } else {\r
+ if (BaseListMarker == NULL) {\r
+ Precision = VA_ARG (VaListMarker, UINTN);\r
+ } else {\r
+ Precision = BASE_ARG (BaseListMarker, UINTN);\r
+ }\r
+ }\r
+ break;\r
+ case '0':\r
+ if ((Flags & PRECISION) == 0) {\r
+ Flags |= PREFIX_ZERO;\r
+ }\r
+ case '1':\r
+ case '2':\r
+ case '3':\r
+ case '4':\r
+ case '5':\r
+ case '6':\r
+ case '7':\r
+ case '8':\r
+ case '9':\r
+ for (Count = 0; ((FormatCharacter >= '0') && (FormatCharacter <= '9')); ){\r
+ Count = (Count * 10) + FormatCharacter - '0';\r
+ Format += BytesPerFormatCharacter;\r
+ FormatCharacter = ((*Format & 0xff) | (*(Format + 1) << 8)) & FormatMask;\r
+ }\r
+ Format -= BytesPerFormatCharacter;\r
+ if ((Flags & PRECISION) == 0) {\r
+ Flags |= PAD_TO_WIDTH;\r
+ Width = Count;\r
+ } else {\r
+ Precision = Count;\r
+ }\r
+ break;\r
+ \r
+ case '\0':\r
+ //\r
+ // Make no output if Format string terminates unexpectedly when\r
+ // looking up for flag, width, precision and type. \r
+ //\r
+ Format -= BytesPerFormatCharacter;\r
+ Precision = 0;\r
+ //\r
+ // break skipped on purpose.\r
+ //\r
+ default:\r
+ Done = TRUE;\r
+ break;\r
+ }\r
+ } \r
+\r
+ //\r
+ // Handle each argument type\r
+ //\r
+ switch (FormatCharacter) {\r
+ case 'p':\r
+ //\r
+ // Flag space, +, 0, L & l are invalid for type p.\r
+ //\r
+ Flags &= ~((UINTN) (PREFIX_BLANK | PREFIX_SIGN | PREFIX_ZERO | LONG_TYPE));\r
+ if (sizeof (VOID *) > 4) {\r
+ Flags |= LONG_TYPE;\r
+ }\r
+ //\r
+ // break skipped on purpose\r
+ //\r
+ case 'X':\r
+ Flags |= PREFIX_ZERO;\r
+ //\r
+ // break skipped on purpose\r
+ //\r
+ case 'x':\r
+ Flags |= RADIX_HEX;\r
+ //\r
+ // break skipped on purpose\r
+ //\r
+ case 'u':\r
+ if ((Flags & RADIX_HEX) == 0) {\r
+ Flags &= ~((UINTN) (PREFIX_SIGN));\r
+ Flags |= UNSIGNED_TYPE;\r
+ }\r
+ //\r
+ // break skipped on purpose\r
+ //\r
+ case 'd':\r
+ if ((Flags & LONG_TYPE) == 0) {\r
+ //\r
+ // 'd', 'u', 'x', and 'X' that are not preceded by 'l' or 'L' are assumed to be type "int".\r
+ // This assumption is made so the format string definition is compatible with the ANSI C\r
+ // Specification for formatted strings. It is recommended that the Base Types be used \r
+ // everywhere, but in this one case, compliance with ANSI C is more important, and \r
+ // provides an implementation that is compatible with that largest possible set of CPU \r
+ // architectures. This is why the type "int" is used in this one case.\r
+ //\r
+ if (BaseListMarker == NULL) {\r
+ Value = VA_ARG (VaListMarker, int);\r
+ } else {\r
+ Value = BASE_ARG (BaseListMarker, int);\r
+ }\r
+ } else {\r
+ if (BaseListMarker == NULL) {\r
+ Value = VA_ARG (VaListMarker, INT64);\r
+ } else {\r
+ Value = BASE_ARG (BaseListMarker, INT64);\r
+ }\r
+ }\r
+ if ((Flags & PREFIX_BLANK) != 0) {\r
+ Prefix = ' ';\r
+ }\r
+ if ((Flags & PREFIX_SIGN) != 0) {\r
+ Prefix = '+';\r
+ }\r
+ if ((Flags & COMMA_TYPE) != 0) {\r
+ Comma = TRUE;\r
+ }\r
+ if ((Flags & RADIX_HEX) == 0) {\r
+ Radix = 10;\r
+ if (Comma) {\r
+ Flags &= ~((UINTN) PREFIX_ZERO);\r
+ Precision = 1;\r
+ }\r
+ if (Value < 0 && (Flags & UNSIGNED_TYPE) == 0) {\r
+ Flags |= PREFIX_SIGN;\r
+ Prefix = '-';\r
+ Value = -Value;\r
+ } else if ((Flags & UNSIGNED_TYPE) != 0 && (Flags & LONG_TYPE) == 0) {\r
+ //\r
+ // 'd', 'u', 'x', and 'X' that are not preceded by 'l' or 'L' are assumed to be type "int".\r
+ // This assumption is made so the format string definition is compatible with the ANSI C\r
+ // Specification for formatted strings. It is recommended that the Base Types be used \r
+ // everywhere, but in this one case, compliance with ANSI C is more important, and \r
+ // provides an implementation that is compatible with that largest possible set of CPU \r
+ // architectures. This is why the type "unsigned int" is used in this one case.\r
+ //\r
+ Value = (unsigned int)Value;\r
+ }\r
+ } else {\r
+ Radix = 16;\r
+ Comma = FALSE;\r
+ if ((Flags & LONG_TYPE) == 0 && Value < 0) {\r
+ //\r
+ // 'd', 'u', 'x', and 'X' that are not preceded by 'l' or 'L' are assumed to be type "int".\r
+ // This assumption is made so the format string definition is compatible with the ANSI C\r
+ // Specification for formatted strings. It is recommended that the Base Types be used \r
+ // everywhere, but in this one case, compliance with ANSI C is more important, and \r
+ // provides an implementation that is compatible with that largest possible set of CPU \r
+ // architectures. This is why the type "unsigned int" is used in this one case.\r
+ //\r
+ Value = (unsigned int)Value;\r
+ }\r
+ }\r
+ //\r
+ // Convert Value to a reversed string\r
+ //\r
+ Count = BasePrintLibValueToString (ValueBuffer, Value, Radix) - ValueBuffer;\r
+ if (Value == 0 && Precision == 0) {\r
+ Count = 0;\r
+ }\r
+ ArgumentString = (CHAR8 *)ValueBuffer + Count;\r
+ \r
+ Digits = Count % 3;\r
+ if (Digits != 0) {\r
+ Digits = 3 - Digits;\r
+ }\r
+ if (Comma && Count != 0) {\r
+ Count += ((Count - 1) / 3);\r
+ }\r
+ if (Prefix != 0) {\r
+ Count++;\r
+ Precision++;\r
+ }\r
+ Flags |= ARGUMENT_REVERSED;\r
+ ZeroPad = TRUE;\r
+ if ((Flags & PREFIX_ZERO) != 0) {\r
+ if ((Flags & LEFT_JUSTIFY) == 0) {\r
+ if ((Flags & PAD_TO_WIDTH) != 0) {\r
+ if ((Flags & PRECISION) == 0) {\r
+ Precision = Width;\r
+ }\r
+ }\r
+ }\r
+ }\r
+ break;\r
+\r
+ case 's':\r
+ case 'S':\r
+ Flags |= ARGUMENT_UNICODE;\r
+ //\r
+ // break skipped on purpose\r
+ //\r
+ case 'a':\r
+ if (BaseListMarker == NULL) {\r
+ ArgumentString = VA_ARG (VaListMarker, CHAR8 *);\r
+ } else {\r
+ ArgumentString = BASE_ARG (BaseListMarker, CHAR8 *);\r
+ }\r
+ if (ArgumentString == NULL) {\r
+ Flags &= ~((UINTN) ARGUMENT_UNICODE);\r
+ ArgumentString = "<null string>";\r
+ }\r
+ //\r
+ // Set the default precision for string to be zero if not specified.\r
+ //\r
+ if ((Flags & PRECISION) == 0) {\r
+ Precision = 0;\r
+ }\r
+ break;\r
+\r
+ case 'c':\r
+ if (BaseListMarker == NULL) {\r
+ Character = VA_ARG (VaListMarker, UINTN) & 0xffff;\r
+ } else {\r
+ Character = BASE_ARG (BaseListMarker, UINTN) & 0xffff;\r
+ }\r
+ ArgumentString = (CHAR8 *)&Character;\r
+ Flags |= ARGUMENT_UNICODE;\r
+ break;\r
+\r
+ case 'g':\r
+ if (BaseListMarker == NULL) {\r
+ TmpGuid = VA_ARG (VaListMarker, GUID *);\r
+ } else {\r
+ TmpGuid = BASE_ARG (BaseListMarker, GUID *);\r
+ }\r
+ if (TmpGuid == NULL) {\r
+ ArgumentString = "<null guid>";\r
+ } else {\r
+ GuidData1 = ReadUnaligned32 (&(TmpGuid->Data1));\r
+ GuidData2 = ReadUnaligned16 (&(TmpGuid->Data2));\r
+ GuidData3 = ReadUnaligned16 (&(TmpGuid->Data3));\r
+ BasePrintLibSPrint (\r
+ ValueBuffer,\r
+ MAXIMUM_VALUE_CHARACTERS, \r
+ 0,\r
+ "%08x-%04x-%04x-%02x%02x-%02x%02x%02x%02x%02x%02x",\r
+ GuidData1,\r
+ GuidData2,\r
+ GuidData3,\r
+ TmpGuid->Data4[0],\r
+ TmpGuid->Data4[1],\r
+ TmpGuid->Data4[2],\r
+ TmpGuid->Data4[3],\r
+ TmpGuid->Data4[4],\r
+ TmpGuid->Data4[5],\r
+ TmpGuid->Data4[6],\r
+ TmpGuid->Data4[7]\r
+ );\r
+ ArgumentString = ValueBuffer;\r
+ }\r
+ break;\r
+\r
+ case 't':\r
+ if (BaseListMarker == NULL) {\r
+ TmpTime = VA_ARG (VaListMarker, TIME *); \r
+ } else {\r
+ TmpTime = BASE_ARG (BaseListMarker, TIME *); \r
+ }\r
+ if (TmpTime == NULL) {\r
+ ArgumentString = "<null time>";\r
+ } else {\r
+ BasePrintLibSPrint (\r
+ ValueBuffer,\r
+ MAXIMUM_VALUE_CHARACTERS,\r
+ 0,\r
+ "%02d/%02d/%04d %02d:%02d",\r
+ TmpTime->Month,\r
+ TmpTime->Day,\r
+ TmpTime->Year,\r
+ TmpTime->Hour,\r
+ TmpTime->Minute\r
+ );\r
+ ArgumentString = ValueBuffer;\r
+ }\r
+ break;\r
+\r
+ case 'r':\r
+ if (BaseListMarker == NULL) {\r
+ Status = VA_ARG (VaListMarker, RETURN_STATUS);\r
+ } else {\r
+ Status = BASE_ARG (BaseListMarker, RETURN_STATUS);\r
+ }\r
+ ArgumentString = ValueBuffer;\r
+ if (RETURN_ERROR (Status)) {\r
+ //\r
+ // Clear error bit\r
+ //\r
+ Index = Status & ~MAX_BIT;\r
+ if (Index > 0 && Index <= ERROR_STATUS_NUMBER) {\r
+ ArgumentString = mStatusString [Index + WARNING_STATUS_NUMBER];\r
+ }\r
+ } else {\r
+ Index = Status;\r
+ if (Index <= WARNING_STATUS_NUMBER) {\r
+ ArgumentString = mStatusString [Index];\r
+ }\r
+ }\r
+ if (ArgumentString == ValueBuffer) {\r
+ BasePrintLibSPrint ((CHAR8 *) ValueBuffer, MAXIMUM_VALUE_CHARACTERS, 0, "%08X", Status);\r
+ }\r
+ break;\r
+\r
+ case '\r':\r
+ Format += BytesPerFormatCharacter;\r
+ FormatCharacter = ((*Format & 0xff) | (*(Format + 1) << 8)) & FormatMask;\r
+ if (FormatCharacter == '\n') {\r
+ //\r
+ // Translate '\r\n' to '\r\n'\r
+ //\r
+ ArgumentString = "\r\n";\r
+ } else {\r
+ //\r
+ // Translate '\r' to '\r'\r
+ //\r
+ ArgumentString = "\r";\r
+ Format -= BytesPerFormatCharacter;\r
+ }\r
+ break;\r
+\r
+ case '\n':\r
+ //\r
+ // Translate '\n' to '\r\n' and '\n\r' to '\r\n'\r
+ //\r
+ ArgumentString = "\r\n";\r
+ Format += BytesPerFormatCharacter;\r
+ FormatCharacter = ((*Format & 0xff) | (*(Format + 1) << 8)) & FormatMask;\r
+ if (FormatCharacter != '\r') {\r
+ Format -= BytesPerFormatCharacter;\r
+ }\r
+ break;\r
+\r
+ case '%':\r
+ default:\r
+ //\r
+ // if the type is '%' or unknown, then print it to the screen\r
+ //\r
+ ArgumentString = (CHAR8 *)&FormatCharacter;\r
+ Flags |= ARGUMENT_UNICODE;\r
+ break;\r
+ }\r
+ break;\r
+ \r
+ case '\r':\r
+ Format += BytesPerFormatCharacter;\r
+ FormatCharacter = ((*Format & 0xff) | (*(Format + 1) << 8)) & FormatMask;\r
+ if (FormatCharacter == '\n') {\r
+ //\r
+ // Translate '\r\n' to '\r\n'\r
+ //\r
+ ArgumentString = "\r\n";\r
+ } else {\r
+ //\r
+ // Translate '\r' to '\r'\r
+ //\r
+ ArgumentString = "\r";\r
+ Format -= BytesPerFormatCharacter;\r
+ }\r
+ break;\r
+\r
+ case '\n':\r
+ //\r
+ // Translate '\n' to '\r\n' and '\n\r' to '\r\n'\r
+ //\r
+ ArgumentString = "\r\n";\r
+ Format += BytesPerFormatCharacter;\r
+ FormatCharacter = ((*Format & 0xff) | (*(Format + 1) << 8)) & FormatMask;\r
+ if (FormatCharacter != '\r') {\r
+ Format -= BytesPerFormatCharacter;\r
+ }\r
+ break;\r
+\r
+ default:\r
+ ArgumentString = (CHAR8 *)&FormatCharacter;\r
+ Flags |= ARGUMENT_UNICODE;\r
+ break;\r
+ }\r
+\r
+ //\r
+ // Retrieve the ArgumentString attriubutes\r
+ //\r
+ if ((Flags & ARGUMENT_UNICODE) != 0) {\r
+ ArgumentMask = 0xffff;\r
+ BytesPerArgumentCharacter = 2;\r
+ } else {\r
+ ArgumentMask = 0xff;\r
+ BytesPerArgumentCharacter = 1;\r
+ }\r
+ if ((Flags & ARGUMENT_REVERSED) != 0) {\r
+ BytesPerArgumentCharacter = -BytesPerArgumentCharacter;\r
+ } else {\r
+ //\r
+ // Compute the number of characters in ArgumentString and store it in Count\r
+ // ArgumentString is either null-terminated, or it contains Precision characters\r
+ //\r
+ for (Count = 0; Count < Precision || ((Flags & PRECISION) == 0); Count++) {\r
+ ArgumentCharacter = ((ArgumentString[Count * BytesPerArgumentCharacter] & 0xff) | ((ArgumentString[Count * BytesPerArgumentCharacter + 1]) << 8)) & ArgumentMask;\r
+ if (ArgumentCharacter == 0) {\r
+ break;\r
+ }\r
+ }\r
+ }\r
+\r
+ if (Precision < Count) {\r
+ Precision = Count;\r
+ }\r
+\r
+ //\r
+ // Pad before the string\r
+ //\r
+ if ((Flags & (PAD_TO_WIDTH | LEFT_JUSTIFY)) == (PAD_TO_WIDTH)) {\r
+ LengthToReturn += ((Width - Precision) * BytesPerOutputCharacter);\r
+ if ((Flags & COUNT_ONLY_NO_PRINT) == 0 && Buffer != NULL) {\r
+ Buffer = BasePrintLibFillBuffer (Buffer, EndBuffer, Width - Precision, ' ', BytesPerOutputCharacter);\r
+ }\r
+ }\r
+\r
+ if (ZeroPad) {\r
+ if (Prefix != 0) {\r
+ LengthToReturn += (1 * BytesPerOutputCharacter);\r
+ if ((Flags & COUNT_ONLY_NO_PRINT) == 0 && Buffer != NULL) {\r
+ Buffer = BasePrintLibFillBuffer (Buffer, EndBuffer, 1, Prefix, BytesPerOutputCharacter);\r
+ }\r
+ }\r
+ LengthToReturn += ((Precision - Count) * BytesPerOutputCharacter);\r
+ if ((Flags & COUNT_ONLY_NO_PRINT) == 0 && Buffer != NULL) {\r
+ Buffer = BasePrintLibFillBuffer (Buffer, EndBuffer, Precision - Count, '0', BytesPerOutputCharacter);\r
+ }\r
+ } else {\r
+ LengthToReturn += ((Precision - Count) * BytesPerOutputCharacter);\r
+ if ((Flags & COUNT_ONLY_NO_PRINT) == 0 && Buffer != NULL) {\r
+ Buffer = BasePrintLibFillBuffer (Buffer, EndBuffer, Precision - Count, ' ', BytesPerOutputCharacter);\r
+ }\r
+ if (Prefix != 0) {\r
+ LengthToReturn += (1 * BytesPerOutputCharacter);\r
+ if ((Flags & COUNT_ONLY_NO_PRINT) == 0 && Buffer != NULL) {\r
+ Buffer = BasePrintLibFillBuffer (Buffer, EndBuffer, 1, Prefix, BytesPerOutputCharacter);\r
+ }\r
+ }\r
+ }\r
+\r
+ //\r
+ // Output the Prefix character if it is present\r
+ //\r
+ Index = 0;\r
+ if (Prefix != 0) {\r
+ Index++;\r
+ }\r
+\r
+ //\r
+ // Copy the string into the output buffer performing the required type conversions\r
+ //\r
+ while (Index < Count) {\r
+ ArgumentCharacter = ((*ArgumentString & 0xff) | (*(ArgumentString + 1) << 8)) & ArgumentMask;\r
+\r
+ LengthToReturn += (1 * BytesPerOutputCharacter);\r
+ if ((Flags & COUNT_ONLY_NO_PRINT) == 0 && Buffer != NULL) {\r
+ Buffer = BasePrintLibFillBuffer (Buffer, EndBuffer, 1, ArgumentCharacter, BytesPerOutputCharacter);\r
+ }\r
+ ArgumentString += BytesPerArgumentCharacter;\r
+ Index++;\r
+ if (Comma) {\r
+ Digits++;\r
+ if (Digits == 3) {\r
+ Digits = 0;\r
+ Index++;\r
+ if (Index < Count) {\r
+ LengthToReturn += (1 * BytesPerOutputCharacter);\r
+ if ((Flags & COUNT_ONLY_NO_PRINT) == 0 && Buffer != NULL) {\r
+ Buffer = BasePrintLibFillBuffer (Buffer, EndBuffer, 1, ',', BytesPerOutputCharacter);\r
+ }\r
+ }\r
+ }\r
+ }\r
+ }\r
+\r
+ //\r
+ // Pad after the string\r
+ //\r
+ if ((Flags & (PAD_TO_WIDTH | LEFT_JUSTIFY)) == (PAD_TO_WIDTH | LEFT_JUSTIFY)) {\r
+ LengthToReturn += ((Width - Precision) * BytesPerOutputCharacter);\r
+ if ((Flags & COUNT_ONLY_NO_PRINT) == 0 && Buffer != NULL) {\r
+ Buffer = BasePrintLibFillBuffer (Buffer, EndBuffer, Width - Precision, ' ', BytesPerOutputCharacter);\r
+ }\r
+ }\r
+\r
+ //\r
+ // Get the next character from the format string\r
+ //\r
+ Format += BytesPerFormatCharacter;\r
+\r
+ //\r
+ // Get the next character from the format string\r
+ //\r
+ FormatCharacter = ((*Format & 0xff) | (*(Format + 1) << 8)) & FormatMask;\r
+ }\r
+\r
+ if ((Flags & COUNT_ONLY_NO_PRINT) != 0) {\r
+ return (LengthToReturn / BytesPerOutputCharacter);\r
+ }\r
+\r
+ ASSERT (Buffer != NULL);\r
+ //\r
+ // Null terminate the Unicode or ASCII string\r
+ //\r
+ BasePrintLibFillBuffer (Buffer, EndBuffer + BytesPerOutputCharacter, 1, 0, BytesPerOutputCharacter);\r
+\r
+ return ((Buffer - OriginalBuffer) / BytesPerOutputCharacter);\r
+}\r
+\r
+/**\r
+ Worker function that produces a Null-terminated string in an output buffer \r
+ based on a Null-terminated format string and variable argument list.\r
+\r
+ VSPrint function to process format and place the results in Buffer. Since a \r
+ VA_LIST is used this routine allows the nesting of Vararg routines. Thus \r
+ this is the main print working routine\r
+\r
+ @param StartOfBuffer The character buffer to print the results of the parsing\r
+ of Format into.\r
+ @param BufferSize The maximum number of characters to put into buffer.\r
+ Zero means no limit.\r
+ @param Flags Initial flags value.\r
+ Can only have FORMAT_UNICODE and OUTPUT_UNICODE set\r
+ @param FormatString A Null-terminated format string.\r
+ @param ... The variable argument list.\r
+\r
+ @return The number of characters printed.\r
+\r
+**/\r
+UINTN\r
+EFIAPI\r
+BasePrintLibSPrint (\r
+ OUT CHAR8 *StartOfBuffer,\r
+ IN UINTN BufferSize,\r
+ IN UINTN Flags,\r
+ IN CONST CHAR8 *FormatString,\r
+ ...\r
+ )\r
+{\r
+ VA_LIST Marker;\r
+ UINTN NumberOfPrinted;\r
+\r
+ VA_START (Marker, FormatString);\r
+ NumberOfPrinted = BasePrintLibSPrintMarker (StartOfBuffer, BufferSize, Flags, FormatString, Marker, NULL);\r
+ VA_END (Marker);\r
+ return NumberOfPrinted;\r
+}\r
projects / mirror_edk2.git / blobdiff