2 Print Library internal worker functions.
4 Copyright (c) 2006 - 2012, Intel Corporation. All rights reserved.<BR>
5 This program and the accompanying materials
6 are licensed and made available under the terms and conditions of the BSD License
7 which accompanies this distribution. The full text of the license may be found at
8 http://opensource.org/licenses/bsd-license.php.
10 THE PROGRAM IS DISTRIBUTED UNDER THE BSD LICENSE ON AN "AS IS" BASIS,
11 WITHOUT WARRANTIES OR REPRESENTATIONS OF ANY KIND, EITHER EXPRESS OR IMPLIED.
15 #include "PrintLibInternal.h"
17 #define WARNING_STATUS_NUMBER 4
18 #define ERROR_STATUS_NUMBER 24
20 GLOBAL_REMOVE_IF_UNREFERENCED CONST CHAR8 mHexStr
[] = {'0','1','2','3','4','5','6','7','8','9','A','B','C','D','E','F'};
22 GLOBAL_REMOVE_IF_UNREFERENCED CONST CHAR8
*mStatusString
[] = {
23 "Success", // RETURN_SUCCESS = 0
24 "Warning Unknown Glyph", // RETURN_WARN_UNKNOWN_GLYPH = 1
25 "Warning Delete Failure", // RETURN_WARN_DELETE_FAILURE = 2
26 "Warning Write Failure", // RETURN_WARN_WRITE_FAILURE = 3
27 "Warning Buffer Too Small", // RETURN_WARN_BUFFER_TOO_SMALL = 4
28 "Load Error", // RETURN_LOAD_ERROR = 1 | MAX_BIT
29 "Invalid Parameter", // RETURN_INVALID_PARAMETER = 2 | MAX_BIT
30 "Unsupported", // RETURN_UNSUPPORTED = 3 | MAX_BIT
31 "Bad Buffer Size", // RETURN_BAD_BUFFER_SIZE = 4 | MAX_BIT
32 "Buffer Too Small", // RETURN_BUFFER_TOO_SMALL, = 5 | MAX_BIT
33 "Not Ready", // RETURN_NOT_READY = 6 | MAX_BIT
34 "Device Error", // RETURN_DEVICE_ERROR = 7 | MAX_BIT
35 "Write Protected", // RETURN_WRITE_PROTECTED = 8 | MAX_BIT
36 "Out of Resources", // RETURN_OUT_OF_RESOURCES = 9 | MAX_BIT
37 "Volume Corrupt", // RETURN_VOLUME_CORRUPTED = 10 | MAX_BIT
38 "Volume Full", // RETURN_VOLUME_FULL = 11 | MAX_BIT
39 "No Media", // RETURN_NO_MEDIA = 12 | MAX_BIT
40 "Media changed", // RETURN_MEDIA_CHANGED = 13 | MAX_BIT
41 "Not Found", // RETURN_NOT_FOUND = 14 | MAX_BIT
42 "Access Denied", // RETURN_ACCESS_DENIED = 15 | MAX_BIT
43 "No Response", // RETURN_NO_RESPONSE = 16 | MAX_BIT
44 "No mapping", // RETURN_NO_MAPPING = 17 | MAX_BIT
45 "Time out", // RETURN_TIMEOUT = 18 | MAX_BIT
46 "Not started", // RETURN_NOT_STARTED = 19 | MAX_BIT
47 "Already started", // RETURN_ALREADY_STARTED = 20 | MAX_BIT
48 "Aborted", // RETURN_ABORTED = 21 | MAX_BIT
49 "ICMP Error", // RETURN_ICMP_ERROR = 22 | MAX_BIT
50 "TFTP Error", // RETURN_TFTP_ERROR = 23 | MAX_BIT
51 "Protocol Error" // RETURN_PROTOCOL_ERROR = 24 | MAX_BIT
56 Internal function that places the character into the Buffer.
58 Internal function that places ASCII or Unicode character into the Buffer.
60 @param Buffer The buffer to place the Unicode or ASCII string.
61 @param EndBuffer The end of the input Buffer. No characters will be
63 @param Length The count of character to be placed into Buffer.
64 (Negative value indicates no buffer fill.)
65 @param Character The character to be placed into Buffer.
66 @param Increment The character increment in Buffer.
72 BasePrintLibFillBuffer (
82 for (Index
= 0; Index
< Length
&& Buffer
< EndBuffer
; Index
++) {
83 *Buffer
= (CHAR8
) Character
;
85 *(Buffer
+ 1) = (CHAR8
)(Character
>> 8);
94 Internal function that convert a number to a string in Buffer.
96 Print worker function that converts a decimal or hexadecimal number to an ASCII string in Buffer.
98 @param Buffer Location to place the ASCII string of Value.
99 @param Value The value to convert to a Decimal or Hexadecimal string in Buffer.
100 @param Radix Radix of the value
102 @return A pointer to the end of buffer filled with ASCII string.
106 BasePrintLibValueToString (
107 IN OUT CHAR8
*Buffer
,
115 // Loop to convert one digit at a time in reverse order
119 Value
= (INT64
)DivU64x32Remainder ((UINT64
)Value
, (UINT32
)Radix
, &Remainder
);
120 *(++Buffer
) = mHexStr
[Remainder
];
121 } while (Value
!= 0);
124 // Return pointer of the end of filled buffer.
130 Internal function that converts a decimal value to a Null-terminated string.
132 Converts the decimal number specified by Value to a Null-terminated
133 string specified by Buffer containing at most Width characters.
134 If Width is 0 then a width of MAXIMUM_VALUE_CHARACTERS is assumed.
135 The total number of characters placed in Buffer is returned.
136 If the conversion contains more than Width characters, then only the first
137 Width characters are returned, and the total number of characters
138 required to perform the conversion is returned.
139 Additional conversion parameters are specified in Flags.
140 The Flags bit LEFT_JUSTIFY is always ignored.
141 All conversions are left justified in Buffer.
142 If Width is 0, PREFIX_ZERO is ignored in Flags.
143 If COMMA_TYPE is set in Flags, then PREFIX_ZERO is ignored in Flags, and commas
144 are inserted every 3rd digit starting from the right.
145 If Value is < 0, then the fist character in Buffer is a '-'.
146 If PREFIX_ZERO is set in Flags and PREFIX_ZERO is not being ignored,
147 then Buffer is padded with '0' characters so the combination of the optional '-'
148 sign character, '0' characters, digit characters for Value, and the Null-terminator
149 add up to Width characters.
151 If Buffer is NULL, then ASSERT().
152 If unsupported bits are set in Flags, then ASSERT().
153 If Width >= MAXIMUM_VALUE_CHARACTERS, then ASSERT()
155 @param Buffer The pointer to the output buffer for the produced Null-terminated
157 @param Flags The bitmask of flags that specify left justification, zero pad,
159 @param Value The 64-bit signed value to convert to a string.
160 @param Width The maximum number of characters to place in Buffer, not including
162 @param Increment The character increment in Buffer.
164 @return Total number of characters required to perform the conversion.
168 BasePrintLibConvertValueToString (
169 IN OUT CHAR8
*Buffer
,
176 CHAR8
*OriginalBuffer
;
178 CHAR8 ValueBuffer
[MAXIMUM_VALUE_CHARACTERS
];
179 CHAR8
*ValueBufferPtr
;
186 // Make sure Buffer is not NULL and Width < MAXIMUM
188 ASSERT (Buffer
!= NULL
);
189 ASSERT (Width
< MAXIMUM_VALUE_CHARACTERS
);
191 // Make sure Flags can only contain supported bits.
193 ASSERT ((Flags
& ~(LEFT_JUSTIFY
| COMMA_TYPE
| PREFIX_ZERO
| RADIX_HEX
)) == 0);
196 // If both COMMA_TYPE and RADIX_HEX are set, then ASSERT ()
198 ASSERT (((Flags
& COMMA_TYPE
) == 0) || ((Flags
& RADIX_HEX
) == 0));
200 OriginalBuffer
= Buffer
;
203 // Width is 0 or COMMA_TYPE is set, PREFIX_ZERO is ignored.
205 if (Width
== 0 || (Flags
& COMMA_TYPE
) != 0) {
206 Flags
&= (~PREFIX_ZERO
);
209 // If Width is 0 then a width of MAXIMUM_VALUE_CHARACTERS is assumed.
212 Width
= MAXIMUM_VALUE_CHARACTERS
- 1;
215 // Set the tag for the end of the input Buffer.
217 EndBuffer
= Buffer
+ Width
* Increment
;
220 // Convert decimal negative
222 if ((Value
< 0) && ((Flags
& RADIX_HEX
) == 0)) {
224 Buffer
= BasePrintLibFillBuffer (Buffer
, EndBuffer
, 1, '-', Increment
);
229 // Count the length of the value string.
231 Radix
= ((Flags
& RADIX_HEX
) == 0)? 10 : 16;
232 ValueBufferPtr
= BasePrintLibValueToString (ValueBuffer
, Value
, Radix
);
233 Count
= ValueBufferPtr
- ValueBuffer
;
238 if ((Flags
& PREFIX_ZERO
) != 0) {
239 Buffer
= BasePrintLibFillBuffer (Buffer
, EndBuffer
, Width
- Count
, '0', Increment
);
243 // Print Comma type for every 3 characters
249 for (Index
= 0; Index
< Count
; Index
++) {
250 Buffer
= BasePrintLibFillBuffer (Buffer
, EndBuffer
, 1, *ValueBufferPtr
--, Increment
);
251 if ((Flags
& COMMA_TYPE
) != 0) {
255 if ((Index
+ 1) < Count
) {
256 Buffer
= BasePrintLibFillBuffer (Buffer
, EndBuffer
, 1, ',', Increment
);
263 // Print Null-terminator
265 BasePrintLibFillBuffer (Buffer
, EndBuffer
+ Increment
, 1, 0, Increment
);
267 return ((Buffer
- OriginalBuffer
) / Increment
);
271 Worker function that produces a Null-terminated string in an output buffer
272 based on a Null-terminated format string and a VA_LIST argument list.
274 VSPrint function to process format and place the results in Buffer. Since a
275 VA_LIST is used this routine allows the nesting of Vararg routines. Thus
276 this is the main print working routine.
278 If COUNT_ONLY_NO_PRINT is set in Flags, Buffer will not be modified at all.
280 @param[out] Buffer The character buffer to print the results of the
281 parsing of Format into.
282 @param[in] BufferSize The maximum number of characters to put into
284 @param[in] Flags Initial flags value.
285 Can only have FORMAT_UNICODE, OUTPUT_UNICODE,
286 and COUNT_ONLY_NO_PRINT set.
287 @param[in] Format A Null-terminated format string.
288 @param[in] VaListMarker VA_LIST style variable argument list consumed by
290 @param[in] BaseListMarker BASE_LIST style variable argument list consumed
291 by processing Format.
293 @return The number of characters printed not including the Null-terminator.
294 If COUNT_ONLY_NO_PRINT was set returns the same, but without any
295 modification to Buffer.
299 BasePrintLibSPrintMarker (
303 IN CONST CHAR8
*Format
,
304 IN VA_LIST VaListMarker
, OPTIONAL
305 IN BASE_LIST BaseListMarker OPTIONAL
308 CHAR8
*OriginalBuffer
;
310 CHAR8 ValueBuffer
[MAXIMUM_VALUE_CHARACTERS
];
311 UINT32 BytesPerOutputCharacter
;
312 UINTN BytesPerFormatCharacter
;
314 UINTN FormatCharacter
;
318 CONST CHAR8
*ArgumentString
;
324 INTN BytesPerArgumentCharacter
;
325 UINTN ArgumentCharacter
;
333 RETURN_STATUS Status
;
337 UINTN LengthToReturn
;
340 // If you change this code be sure to match the 2 versions of this function.
341 // Nearly identical logic is found in the BasePrintLib and
342 // DxePrintLibPrint2Protocol (both PrintLib instances).
345 if ((Flags
& COUNT_ONLY_NO_PRINT
) != 0) {
346 if (BufferSize
== 0) {
351 // We can run without a Buffer for counting only.
353 if (BufferSize
== 0) {
356 ASSERT (Buffer
!= NULL
);
359 if ((Flags
& OUTPUT_UNICODE
) != 0) {
360 BytesPerOutputCharacter
= 2;
362 BytesPerOutputCharacter
= 1;
368 // Reserve space for the Null terminator.
371 OriginalBuffer
= Buffer
;
374 // Set the tag for the end of the input Buffer.
376 EndBuffer
= Buffer
+ BufferSize
* BytesPerOutputCharacter
;
378 if ((Flags
& FORMAT_UNICODE
) != 0) {
380 // Make sure format string cannot contain more than PcdMaximumUnicodeStringLength
381 // Unicode characters if PcdMaximumUnicodeStringLength is not zero.
383 ASSERT (StrSize ((CHAR16
*) Format
) != 0);
384 BytesPerFormatCharacter
= 2;
388 // Make sure format string cannot contain more than PcdMaximumAsciiStringLength
389 // Ascii characters if PcdMaximumAsciiStringLength is not zero.
391 ASSERT (AsciiStrSize (Format
) != 0);
392 BytesPerFormatCharacter
= 1;
397 // Get the first character from the format string
399 FormatCharacter
= ((*Format
& 0xff) | (*(Format
+ 1) << 8)) & FormatMask
;
402 // Loop until the end of the format string is reached or the output buffer is full
404 while (FormatCharacter
!= 0 && Buffer
< EndBuffer
) {
406 // Clear all the flag bits except those that may have been passed in
408 Flags
&= (OUTPUT_UNICODE
| FORMAT_UNICODE
| COUNT_ONLY_NO_PRINT
);
411 // Set the default width to zero, and the default precision to 1
421 switch (FormatCharacter
) {
424 // Parse Flags and Width
426 for (Done
= FALSE
; !Done
; ) {
427 Format
+= BytesPerFormatCharacter
;
428 FormatCharacter
= ((*Format
& 0xff) | (*(Format
+ 1) << 8)) & FormatMask
;
429 switch (FormatCharacter
) {
434 Flags
|= LEFT_JUSTIFY
;
437 Flags
|= PREFIX_SIGN
;
440 Flags
|= PREFIX_BLANK
;
450 if ((Flags
& PRECISION
) == 0) {
451 Flags
|= PAD_TO_WIDTH
;
452 if (BaseListMarker
== NULL
) {
453 Width
= VA_ARG (VaListMarker
, UINTN
);
455 Width
= BASE_ARG (BaseListMarker
, UINTN
);
458 if (BaseListMarker
== NULL
) {
459 Precision
= VA_ARG (VaListMarker
, UINTN
);
461 Precision
= BASE_ARG (BaseListMarker
, UINTN
);
466 if ((Flags
& PRECISION
) == 0) {
467 Flags
|= PREFIX_ZERO
;
478 for (Count
= 0; ((FormatCharacter
>= '0') && (FormatCharacter
<= '9')); ){
479 Count
= (Count
* 10) + FormatCharacter
- '0';
480 Format
+= BytesPerFormatCharacter
;
481 FormatCharacter
= ((*Format
& 0xff) | (*(Format
+ 1) << 8)) & FormatMask
;
483 Format
-= BytesPerFormatCharacter
;
484 if ((Flags
& PRECISION
) == 0) {
485 Flags
|= PAD_TO_WIDTH
;
494 // Make no output if Format string terminates unexpectedly when
495 // looking up for flag, width, precision and type.
497 Format
-= BytesPerFormatCharacter
;
500 // break skipped on purpose.
509 // Handle each argument type
511 switch (FormatCharacter
) {
514 // Flag space, +, 0, L & l are invalid for type p.
516 Flags
&= ~(PREFIX_BLANK
| PREFIX_SIGN
| PREFIX_ZERO
| LONG_TYPE
);
517 if (sizeof (VOID
*) > 4) {
521 // break skipped on purpose
524 Flags
|= PREFIX_ZERO
;
526 // break skipped on purpose
531 // break skipped on purpose
534 if ((Flags
& LONG_TYPE
) == 0) {
536 // 'd','x', and 'X' that are not preceded by 'l' or 'L' are assumed to be type "int".
537 // This assumption is made so the format string definition is compatible with the ANSI C
538 // Specification for formatted strings. It is recommended that the Base Types be used
539 // everywhere, but in this one case, compliance with ANSI C is more important, and
540 // provides an implementation that is compatible with that largest possible set of CPU
541 // architectures. This is why the type "int" is used in this one case.
543 if (BaseListMarker
== NULL
) {
544 Value
= VA_ARG (VaListMarker
, int);
546 Value
= BASE_ARG (BaseListMarker
, int);
549 if (BaseListMarker
== NULL
) {
550 Value
= VA_ARG (VaListMarker
, INT64
);
552 Value
= BASE_ARG (BaseListMarker
, INT64
);
555 if ((Flags
& PREFIX_BLANK
) != 0) {
558 if ((Flags
& PREFIX_SIGN
) != 0) {
561 if ((Flags
& COMMA_TYPE
) != 0) {
564 if ((Flags
& RADIX_HEX
) == 0) {
567 Flags
&= (~PREFIX_ZERO
);
571 Flags
|= PREFIX_SIGN
;
578 if ((Flags
& LONG_TYPE
) == 0 && Value
< 0) {
580 // 'd','x', and 'X' that are not preceded by 'l' or 'L' are assumed to be type "int".
581 // This assumption is made so the format string definition is compatible with the ANSI C
582 // Specification for formatted strings. It is recommended that the Base Types be used
583 // everywhere, but in this one case, compliance with ANSI C is more important, and
584 // provides an implementation that is compatible with that largest possible set of CPU
585 // architectures. This is why the type "unsigned int" is used in this one case.
587 Value
= (unsigned int)Value
;
591 // Convert Value to a reversed string
593 Count
= BasePrintLibValueToString (ValueBuffer
, Value
, Radix
) - ValueBuffer
;
594 if (Value
== 0 && Precision
== 0) {
597 ArgumentString
= (CHAR8
*)ValueBuffer
+ Count
;
603 if (Comma
&& Count
!= 0) {
604 Count
+= ((Count
- 1) / 3);
610 Flags
|= ARGUMENT_REVERSED
;
612 if ((Flags
& PREFIX_ZERO
) != 0) {
613 if ((Flags
& LEFT_JUSTIFY
) == 0) {
614 if ((Flags
& PAD_TO_WIDTH
) != 0) {
615 if ((Flags
& PRECISION
) == 0) {
625 Flags
|= ARGUMENT_UNICODE
;
627 // break skipped on purpose
630 if (BaseListMarker
== NULL
) {
631 ArgumentString
= VA_ARG (VaListMarker
, CHAR8
*);
633 ArgumentString
= BASE_ARG (BaseListMarker
, CHAR8
*);
635 if (ArgumentString
== NULL
) {
636 Flags
&= (~ARGUMENT_UNICODE
);
637 ArgumentString
= "<null string>";
640 // Set the default precision for string to be zero if not specified.
642 if ((Flags
& PRECISION
) == 0) {
648 if (BaseListMarker
== NULL
) {
649 Character
= VA_ARG (VaListMarker
, UINTN
) & 0xffff;
651 Character
= BASE_ARG (BaseListMarker
, UINTN
) & 0xffff;
653 ArgumentString
= (CHAR8
*)&Character
;
654 Flags
|= ARGUMENT_UNICODE
;
658 if (BaseListMarker
== NULL
) {
659 TmpGuid
= VA_ARG (VaListMarker
, GUID
*);
661 TmpGuid
= BASE_ARG (BaseListMarker
, GUID
*);
663 if (TmpGuid
== NULL
) {
664 ArgumentString
= "<null guid>";
666 GuidData1
= ReadUnaligned32 (&(TmpGuid
->Data1
));
667 GuidData2
= ReadUnaligned16 (&(TmpGuid
->Data2
));
668 GuidData3
= ReadUnaligned16 (&(TmpGuid
->Data3
));
671 MAXIMUM_VALUE_CHARACTERS
,
673 "%08x-%04x-%04x-%02x%02x-%02x%02x%02x%02x%02x%02x",
686 ArgumentString
= ValueBuffer
;
691 if (BaseListMarker
== NULL
) {
692 TmpTime
= VA_ARG (VaListMarker
, TIME
*);
694 TmpTime
= BASE_ARG (BaseListMarker
, TIME
*);
696 if (TmpTime
== NULL
) {
697 ArgumentString
= "<null time>";
701 MAXIMUM_VALUE_CHARACTERS
,
703 "%02d/%02d/%04d %02d:%02d",
710 ArgumentString
= ValueBuffer
;
715 if (BaseListMarker
== NULL
) {
716 Status
= VA_ARG (VaListMarker
, RETURN_STATUS
);
718 Status
= BASE_ARG (BaseListMarker
, RETURN_STATUS
);
720 ArgumentString
= ValueBuffer
;
721 if (RETURN_ERROR (Status
)) {
725 Index
= Status
& ~MAX_BIT
;
726 if (Index
> 0 && Index
<= ERROR_STATUS_NUMBER
) {
727 ArgumentString
= mStatusString
[Index
+ WARNING_STATUS_NUMBER
];
731 if (Index
<= WARNING_STATUS_NUMBER
) {
732 ArgumentString
= mStatusString
[Index
];
735 if (ArgumentString
== ValueBuffer
) {
736 BasePrintLibSPrint ((CHAR8
*) ValueBuffer
, MAXIMUM_VALUE_CHARACTERS
, 0, "%08X", Status
);
741 Format
+= BytesPerFormatCharacter
;
742 FormatCharacter
= ((*Format
& 0xff) | (*(Format
+ 1) << 8)) & FormatMask
;
743 if (FormatCharacter
== '\n') {
745 // Translate '\r\n' to '\r\n'
747 ArgumentString
= "\r\n";
750 // Translate '\r' to '\r'
752 ArgumentString
= "\r";
753 Format
-= BytesPerFormatCharacter
;
759 // Translate '\n' to '\r\n' and '\n\r' to '\r\n'
761 ArgumentString
= "\r\n";
762 Format
+= BytesPerFormatCharacter
;
763 FormatCharacter
= ((*Format
& 0xff) | (*(Format
+ 1) << 8)) & FormatMask
;
764 if (FormatCharacter
!= '\r') {
765 Format
-= BytesPerFormatCharacter
;
772 // if the type is '%' or unknown, then print it to the screen
774 ArgumentString
= (CHAR8
*)&FormatCharacter
;
775 Flags
|= ARGUMENT_UNICODE
;
781 Format
+= BytesPerFormatCharacter
;
782 FormatCharacter
= ((*Format
& 0xff) | (*(Format
+ 1) << 8)) & FormatMask
;
783 if (FormatCharacter
== '\n') {
785 // Translate '\r\n' to '\r\n'
787 ArgumentString
= "\r\n";
790 // Translate '\r' to '\r'
792 ArgumentString
= "\r";
793 Format
-= BytesPerFormatCharacter
;
799 // Translate '\n' to '\r\n' and '\n\r' to '\r\n'
801 ArgumentString
= "\r\n";
802 Format
+= BytesPerFormatCharacter
;
803 FormatCharacter
= ((*Format
& 0xff) | (*(Format
+ 1) << 8)) & FormatMask
;
804 if (FormatCharacter
!= '\r') {
805 Format
-= BytesPerFormatCharacter
;
810 ArgumentString
= (CHAR8
*)&FormatCharacter
;
811 Flags
|= ARGUMENT_UNICODE
;
816 // Retrieve the ArgumentString attriubutes
818 if ((Flags
& ARGUMENT_UNICODE
) != 0) {
819 ArgumentMask
= 0xffff;
820 BytesPerArgumentCharacter
= 2;
823 BytesPerArgumentCharacter
= 1;
825 if ((Flags
& ARGUMENT_REVERSED
) != 0) {
826 BytesPerArgumentCharacter
= -BytesPerArgumentCharacter
;
829 // Compute the number of characters in ArgumentString and store it in Count
830 // ArgumentString is either null-terminated, or it contains Precision characters
832 for (Count
= 0; Count
< Precision
|| ((Flags
& PRECISION
) == 0); Count
++) {
833 ArgumentCharacter
= ((ArgumentString
[Count
* BytesPerArgumentCharacter
] & 0xff) | ((ArgumentString
[Count
* BytesPerArgumentCharacter
+ 1]) << 8)) & ArgumentMask
;
834 if (ArgumentCharacter
== 0) {
840 if (Precision
< Count
) {
845 // Pad before the string
847 if ((Flags
& (PAD_TO_WIDTH
| LEFT_JUSTIFY
)) == (PAD_TO_WIDTH
)) {
848 LengthToReturn
+= ((Width
- Precision
) * BytesPerOutputCharacter
);
849 if ((Flags
& COUNT_ONLY_NO_PRINT
) == 0 && Buffer
!= NULL
) {
850 Buffer
= BasePrintLibFillBuffer (Buffer
, EndBuffer
, Width
- Precision
, ' ', BytesPerOutputCharacter
);
856 LengthToReturn
+= (1 * BytesPerOutputCharacter
);
857 if ((Flags
& COUNT_ONLY_NO_PRINT
) == 0 && Buffer
!= NULL
) {
858 Buffer
= BasePrintLibFillBuffer (Buffer
, EndBuffer
, 1, Prefix
, BytesPerOutputCharacter
);
861 LengthToReturn
+= ((Precision
- Count
) * BytesPerOutputCharacter
);
862 if ((Flags
& COUNT_ONLY_NO_PRINT
) == 0 && Buffer
!= NULL
) {
863 Buffer
= BasePrintLibFillBuffer (Buffer
, EndBuffer
, Precision
- Count
, '0', BytesPerOutputCharacter
);
866 LengthToReturn
+= ((Precision
- Count
) * BytesPerOutputCharacter
);
867 if ((Flags
& COUNT_ONLY_NO_PRINT
) == 0 && Buffer
!= NULL
) {
868 Buffer
= BasePrintLibFillBuffer (Buffer
, EndBuffer
, Precision
- Count
, ' ', BytesPerOutputCharacter
);
871 LengthToReturn
+= (1 * BytesPerOutputCharacter
);
872 if ((Flags
& COUNT_ONLY_NO_PRINT
) == 0 && Buffer
!= NULL
) {
873 Buffer
= BasePrintLibFillBuffer (Buffer
, EndBuffer
, 1, Prefix
, BytesPerOutputCharacter
);
879 // Output the Prefix character if it is present
887 // Copy the string into the output buffer performing the required type conversions
889 while (Index
< Count
) {
890 ArgumentCharacter
= ((*ArgumentString
& 0xff) | (*(ArgumentString
+ 1) << 8)) & ArgumentMask
;
892 LengthToReturn
+= (1 * BytesPerOutputCharacter
);
893 if ((Flags
& COUNT_ONLY_NO_PRINT
) == 0 && Buffer
!= NULL
) {
894 Buffer
= BasePrintLibFillBuffer (Buffer
, EndBuffer
, 1, ArgumentCharacter
, BytesPerOutputCharacter
);
896 ArgumentString
+= BytesPerArgumentCharacter
;
904 LengthToReturn
+= (1 * BytesPerOutputCharacter
);
905 if ((Flags
& COUNT_ONLY_NO_PRINT
) == 0 && Buffer
!= NULL
) {
906 Buffer
= BasePrintLibFillBuffer (Buffer
, EndBuffer
, 1, ',', BytesPerOutputCharacter
);
914 // Pad after the string
916 if ((Flags
& (PAD_TO_WIDTH
| LEFT_JUSTIFY
)) == (PAD_TO_WIDTH
| LEFT_JUSTIFY
)) {
917 LengthToReturn
+= ((Width
- Precision
) * BytesPerOutputCharacter
);
918 if ((Flags
& COUNT_ONLY_NO_PRINT
) == 0 && Buffer
!= NULL
) {
919 Buffer
= BasePrintLibFillBuffer (Buffer
, EndBuffer
, Width
- Precision
, ' ', BytesPerOutputCharacter
);
924 // Get the next character from the format string
926 Format
+= BytesPerFormatCharacter
;
929 // Get the next character from the format string
931 FormatCharacter
= ((*Format
& 0xff) | (*(Format
+ 1) << 8)) & FormatMask
;
934 if ((Flags
& COUNT_ONLY_NO_PRINT
) != 0) {
935 return (LengthToReturn
/ BytesPerOutputCharacter
);
938 ASSERT (Buffer
!= NULL
);
940 // Null terminate the Unicode or ASCII string
942 BasePrintLibFillBuffer (Buffer
, EndBuffer
+ BytesPerOutputCharacter
, 1, 0, BytesPerOutputCharacter
);
944 // Make sure output buffer cannot contain more than PcdMaximumUnicodeStringLength
945 // Unicode characters if PcdMaximumUnicodeStringLength is not zero.
947 ASSERT ((((Flags
& OUTPUT_UNICODE
) == 0)) || (StrSize ((CHAR16
*) OriginalBuffer
) != 0));
949 // Make sure output buffer cannot contain more than PcdMaximumAsciiStringLength
950 // ASCII characters if PcdMaximumAsciiStringLength is not zero.
952 ASSERT ((((Flags
& OUTPUT_UNICODE
) != 0)) || (AsciiStrSize (OriginalBuffer
) != 0));
954 return ((Buffer
- OriginalBuffer
) / BytesPerOutputCharacter
);
958 Worker function that produces a Null-terminated string in an output buffer
959 based on a Null-terminated format string and variable argument list.
961 VSPrint function to process format and place the results in Buffer. Since a
962 VA_LIST is used this routine allows the nesting of Vararg routines. Thus
963 this is the main print working routine
965 @param StartOfBuffer The character buffer to print the results of the parsing
967 @param BufferSize The maximum number of characters to put into buffer.
969 @param Flags Initial flags value.
970 Can only have FORMAT_UNICODE and OUTPUT_UNICODE set
971 @param FormatString A Null-terminated format string.
972 @param ... The variable argument list.
974 @return The number of characters printed.
980 OUT CHAR8
*StartOfBuffer
,
983 IN CONST CHAR8
*FormatString
,
988 UINTN NumberOfPrinted
;
990 VA_START (Marker
, FormatString
);
991 NumberOfPrinted
= BasePrintLibSPrintMarker (StartOfBuffer
, BufferSize
, Flags
, FormatString
, Marker
, NULL
);
993 return NumberOfPrinted
;