2 Print Library internal worker functions.
4 Copyright (c) 2006 - 2008, Intel Corporation<BR>
5 All rights reserved. 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 Buffer to place the Unicode or ASCII string.
61 @param EndBuffer The end of the input Buffer. No characters will be
63 @param Length Count of character to be placed into Buffer.
64 (Negative value indicates no buffer fill.)
65 @param Character Character to be placed into Buffer.
66 @param Increment Character increment in Buffer.
68 @return Buffer Buffer filled with the input Character.
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 decimal number to a string in Buffer.
96 Print worker function that convert a decimal number to a string in Buffer.
98 @param Buffer Location to place the Unicode or ASCII string of Value.
99 @param Value Value to convert to a Decimal or Hexadecimal string in Buffer.
100 @param Radix Radix of the value
102 @return Number of characters printed.
106 BasePrintLibValueToString (
107 IN OUT CHAR8
*Buffer
,
116 // Loop to convert one digit at a time in reverse order
121 Value
= (INT64
)DivU64x32Remainder ((UINT64
)Value
, (UINT32
)Radix
, &Remainder
);
122 *(Buffer
++) = mHexStr
[Remainder
];
124 } while (Value
!= 0);
127 // the length of Buffer string converted from Value
133 Internal function that converts a decimal value to a Null-terminated string.
135 Converts the decimal number specified by Value to a Null-terminated
136 string specified by Buffer containing at most Width characters.
137 If Width is 0 then a width of MAXIMUM_VALUE_CHARACTERS is assumed.
138 The total number of characters placed in Buffer is returned.
139 If the conversion contains more than Width characters, then only the first
140 Width characters are returned, and the total number of characters
141 required to perform the conversion is returned.
142 Additional conversion parameters are specified in Flags.
143 The Flags bit LEFT_JUSTIFY is always ignored.
144 All conversions are left justified in Buffer.
145 If Width is 0, PREFIX_ZERO is ignored in Flags.
146 If COMMA_TYPE is set in Flags, then PREFIX_ZERO is ignored in Flags, and commas
147 are inserted every 3rd digit starting from the right.
148 If Value is < 0, then the fist character in Buffer is a '-'.
149 If PREFIX_ZERO is set in Flags and PREFIX_ZERO is not being ignored,
150 then Buffer is padded with '0' characters so the combination of the optional '-'
151 sign character, '0' characters, digit characters for Value, and the Null-terminator
152 add up to Width characters.
154 If Buffer is NULL, then ASSERT().
155 If unsupported bits are set in Flags, then ASSERT().
156 If Width >= MAXIMUM_VALUE_CHARACTERS, then ASSERT()
158 @param Buffer Pointer to the output buffer for the produced Null-terminated
160 @param Flags The bitmask of flags that specify left justification, zero pad,
162 @param Value The 64-bit signed value to convert to a string.
163 @param Width The maximum number of characters to place in Buffer, not including
165 @param Increment Character increment in Buffer.
167 @return Total number of characters required to perform the conversion.
171 BasePrintLibConvertValueToString (
172 IN OUT CHAR8
*Buffer
,
179 CHAR8
*OriginalBuffer
;
181 CHAR8 ValueBuffer
[MAXIMUM_VALUE_CHARACTERS
];
188 // Make sure Buffer is not NULL and Width < MAXIMUM
190 ASSERT (Buffer
!= NULL
);
191 ASSERT (Width
< MAXIMUM_VALUE_CHARACTERS
);
193 // Make sure Flags can only contain supported bits.
195 ASSERT ((Flags
& ~(LEFT_JUSTIFY
| COMMA_TYPE
| PREFIX_ZERO
| RADIX_HEX
)) == 0);
198 // If both COMMA_TYPE and HEX_RADIX are set, then ASSERT ()
200 ASSERT (((Flags
& COMMA_TYPE
) == 0) || ((Flags
& RADIX_HEX
) == 0));
202 OriginalBuffer
= Buffer
;
205 // Width is 0 or COMMA_TYPE is set, PREFIX_ZERO is ignored.
207 if (Width
== 0 || (Flags
& COMMA_TYPE
) != 0) {
208 Flags
&= (~PREFIX_ZERO
);
211 // If Width is 0 then a width of MAXIMUM_VALUE_CHARACTERS is assumed.
214 Width
= MAXIMUM_VALUE_CHARACTERS
- 1;
217 // Set the tag for the end of the input Buffer.
219 EndBuffer
= Buffer
+ Width
* Increment
;
222 // Convert decimal negative
224 if ((Value
< 0) && ((Flags
& RADIX_HEX
) == 0)) {
226 Buffer
= BasePrintLibFillBuffer (Buffer
, EndBuffer
, 1, '-', Increment
);
231 // Count the length of the value string.
233 Radix
= ((Flags
& RADIX_HEX
) == 0)? 10 : 16;
234 Count
= BasePrintLibValueToString (ValueBuffer
, Value
, Radix
);
239 if ((Flags
& PREFIX_ZERO
) != 0) {
240 Buffer
= BasePrintLibFillBuffer (Buffer
, EndBuffer
, Width
- Count
, '0', Increment
);
244 // Print Comma type for every 3 characters
250 for (Index
= 0; Index
< Count
; Index
++) {
251 Buffer
= BasePrintLibFillBuffer (Buffer
, EndBuffer
, 1, ValueBuffer
[Count
- Index
], Increment
);
252 if ((Flags
& COMMA_TYPE
) != 0) {
256 if ((Index
+ 1) < Count
) {
257 Buffer
= BasePrintLibFillBuffer (Buffer
, EndBuffer
, 1, ',', Increment
);
264 // Print Null-terminator
266 BasePrintLibFillBuffer (Buffer
, EndBuffer
+ Increment
, 1, 0, Increment
);
268 return ((Buffer
- OriginalBuffer
) / Increment
);
272 Worker function that produces a Null-terminated string in an output buffer
273 based on a Null-terminated format string and a VA_LIST argument list.
275 VSPrint function to process format and place the results in Buffer. Since a
276 VA_LIST is used this rountine allows the nesting of Vararg routines. Thus
277 this is the main print working routine.
279 @param Buffer Character buffer to print the results of the parsing
281 @param BufferSize Maximum number of characters to put into buffer.
282 @param Flags Intial flags value.
283 Can only have FORMAT_UNICODE and OUTPUT_UNICODE set.
284 @param Format Null-terminated format string.
285 @param Marker Vararg list consumed by processing Format.
287 @return Number of characters printed not including the Null-terminator.
291 BasePrintLibVSPrint (
295 IN CONST CHAR8
*Format
,
299 CHAR8
*OriginalBuffer
;
301 CHAR8 ValueBuffer
[MAXIMUM_VALUE_CHARACTERS
];
302 UINTN BytesPerOutputCharacter
;
303 UINTN BytesPerFormatCharacter
;
305 UINTN FormatCharacter
;
309 CONST CHAR8
*ArgumentString
;
315 INTN BytesPerArgumentCharacter
;
316 UINTN ArgumentCharacter
;
324 RETURN_STATUS Status
;
326 if (BufferSize
== 0) {
329 ASSERT (Buffer
!= NULL
);
331 if ((Flags
& OUTPUT_UNICODE
) != 0) {
332 BytesPerOutputCharacter
= 2;
334 BytesPerOutputCharacter
= 1;
338 // Reserve space for the Null terminator.
341 OriginalBuffer
= Buffer
;
343 // Set the tag for the end of the input Buffer.
345 EndBuffer
= Buffer
+ BufferSize
* BytesPerOutputCharacter
;
347 if ((Flags
& FORMAT_UNICODE
) != 0) {
349 // Make sure format string cannot contain more than PcdMaximumUnicodeStringLength
350 // Unicode characters if PcdMaximumUnicodeStringLength is not zero.
352 ASSERT (StrSize ((CHAR16
*) Format
) != 0);
353 BytesPerFormatCharacter
= 2;
357 // Make sure format string cannot contain more than PcdMaximumAsciiStringLength
358 // Ascii characters if PcdMaximumAsciiStringLength is not zero.
360 ASSERT (AsciiStrSize (Format
) != 0);
361 BytesPerFormatCharacter
= 1;
368 // Get the first character from the format string
370 FormatCharacter
= ((*Format
& 0xff) | (*(Format
+ 1) << 8)) & FormatMask
;
373 // Loop until the end of the format string is reached or the output buffer is full
375 while (FormatCharacter
!= 0 && Buffer
< EndBuffer
) {
377 // Clear all the flag bits except those that may have been passed in
379 Flags
&= (OUTPUT_UNICODE
| FORMAT_UNICODE
);
382 // Set the default width to zero, and the default precision to 1
392 switch (FormatCharacter
) {
395 // Parse Flags and Width
397 for (Done
= FALSE
; !Done
; ) {
398 Format
+= BytesPerFormatCharacter
;
399 FormatCharacter
= ((*Format
& 0xff) | (*(Format
+ 1) << 8)) & FormatMask
;
400 switch (FormatCharacter
) {
405 Flags
|= LEFT_JUSTIFY
;
408 Flags
|= PREFIX_SIGN
;
411 Flags
|= PREFIX_BLANK
;
421 if ((Flags
& PRECISION
) == 0) {
422 Flags
|= PAD_TO_WIDTH
;
423 Width
= VA_ARG (Marker
, UINTN
);
425 Precision
= VA_ARG (Marker
, UINTN
);
429 if ((Flags
& PRECISION
) == 0) {
430 Flags
|= PREFIX_ZERO
;
441 for (Count
= 0; ((FormatCharacter
>= '0') && (FormatCharacter
<= '9')); ){
442 Count
= (Count
* 10) + FormatCharacter
- '0';
443 Format
+= BytesPerFormatCharacter
;
444 FormatCharacter
= ((*Format
& 0xff) | (*(Format
+ 1) << 8)) & FormatMask
;
446 Format
-= BytesPerFormatCharacter
;
447 if ((Flags
& PRECISION
) == 0) {
448 Flags
|= PAD_TO_WIDTH
;
457 // Make no output if Format string terminates unexpectedly when
458 // looking up for flag, width, precision and type.
460 Format
-= BytesPerFormatCharacter
;
463 // break skipped on purpose.
472 // Handle each argument type
474 switch (FormatCharacter
) {
477 // Flag space, +, 0, L & l are invalid for type p.
479 Flags
&= ~(PREFIX_BLANK
| PREFIX_SIGN
| PREFIX_ZERO
| LONG_TYPE
);
480 if (sizeof (VOID
*) > 4) {
484 Flags
|= PREFIX_ZERO
;
486 // break skipped on purpose
491 // break skipped on purpose
494 if ((Flags
& LONG_TYPE
) == 0) {
495 Value
= (VA_ARG (Marker
, int));
497 Value
= VA_ARG (Marker
, INT64
);
499 if ((Flags
& PREFIX_BLANK
) != 0) {
502 if ((Flags
& PREFIX_SIGN
) != 0) {
505 if ((Flags
& COMMA_TYPE
) != 0) {
508 if ((Flags
& RADIX_HEX
) == 0) {
511 Flags
&= (~PREFIX_ZERO
);
515 Flags
|= PREFIX_SIGN
;
522 if ((Flags
& LONG_TYPE
) == 0 && Value
< 0) {
523 Value
= (unsigned int)Value
;
527 // Convert Value to a reversed string
529 Count
= BasePrintLibValueToString (ValueBuffer
, Value
, Radix
);
530 if (Value
== 0 && Precision
== 0) {
533 ArgumentString
= (CHAR8
*)ValueBuffer
+ Count
;
539 if (Comma
&& Count
!= 0) {
540 Count
+= ((Count
- 1) / 3);
546 Flags
|= ARGUMENT_REVERSED
;
548 if ((Flags
& PREFIX_ZERO
) != 0) {
549 if ((Flags
& LEFT_JUSTIFY
) == 0) {
550 if ((Flags
& PAD_TO_WIDTH
) != 0) {
551 if ((Flags
& PRECISION
) == 0) {
561 Flags
|= ARGUMENT_UNICODE
;
563 // break skipped on purpose
566 ArgumentString
= (CHAR8
*)VA_ARG (Marker
, CHAR8
*);
567 if (ArgumentString
== NULL
) {
568 Flags
&= (~ARGUMENT_UNICODE
);
569 ArgumentString
= "<null string>";
572 // Set the default precision for string to be zero if not specified.
574 if ((Flags
& PRECISION
) == 0) {
580 Character
= VA_ARG (Marker
, UINTN
) & 0xffff;
581 ArgumentString
= (CHAR8
*)&Character
;
582 Flags
|= ARGUMENT_UNICODE
;
586 TmpGuid
= VA_ARG (Marker
, GUID
*);
587 if (TmpGuid
== NULL
) {
588 ArgumentString
= "<null guid>";
592 MAXIMUM_VALUE_CHARACTERS
,
594 "%08x-%04x-%04x-%02x%02x-%02x%02x%02x%02x%02x%02x",
607 ArgumentString
= ValueBuffer
;
612 TmpTime
= VA_ARG (Marker
, TIME
*);
613 if (TmpTime
== NULL
) {
614 ArgumentString
= "<null time>";
618 MAXIMUM_VALUE_CHARACTERS
,
620 "%02d/%02d/%04d %02d:%02d",
627 ArgumentString
= ValueBuffer
;
632 Status
= VA_ARG (Marker
, RETURN_STATUS
);
633 ArgumentString
= ValueBuffer
;
634 if (RETURN_ERROR (Status
)) {
638 Index
= Status
& ~MAX_BIT
;
639 if (Index
> 0 && Index
<= ERROR_STATUS_NUMBER
) {
640 ArgumentString
= mStatusString
[Index
+ WARNING_STATUS_NUMBER
];
644 if (Index
<= WARNING_STATUS_NUMBER
) {
645 ArgumentString
= mStatusString
[Index
];
648 if (ArgumentString
== ValueBuffer
) {
649 BasePrintLibSPrint ((CHAR8
*) ValueBuffer
, MAXIMUM_VALUE_CHARACTERS
, 0, "%08X", Status
);
654 ArgumentString
= "\n\r";
660 // if the type is '%' or unknown, then print it to the screen
662 ArgumentString
= (CHAR8
*)&FormatCharacter
;
663 Flags
|= ARGUMENT_UNICODE
;
669 ArgumentString
= "\n\r";
673 ArgumentString
= (CHAR8
*)&FormatCharacter
;
674 Flags
|= ARGUMENT_UNICODE
;
679 // Retrieve the ArgumentString attriubutes
681 if ((Flags
& ARGUMENT_UNICODE
) != 0) {
682 ArgumentMask
= 0xffff;
683 BytesPerArgumentCharacter
= 2;
686 BytesPerArgumentCharacter
= 1;
688 if ((Flags
& ARGUMENT_REVERSED
) != 0) {
689 BytesPerArgumentCharacter
= -BytesPerArgumentCharacter
;
692 // Compute the number of characters in ArgumentString and store it in Count
693 // ArgumentString is either null-terminated, or it contains Precision characters
695 for (Count
= 0; Count
< Precision
|| ((Flags
& PRECISION
) == 0); Count
++) {
696 ArgumentCharacter
= ((ArgumentString
[Count
* BytesPerArgumentCharacter
] & 0xff) | ((ArgumentString
[Count
* BytesPerArgumentCharacter
+ 1]) << 8)) & ArgumentMask
;
697 if (ArgumentCharacter
== 0) {
703 if (Precision
< Count
) {
708 // Pad before the string
710 if ((Flags
& (PAD_TO_WIDTH
| LEFT_JUSTIFY
)) == (PAD_TO_WIDTH
)) {
711 Buffer
= BasePrintLibFillBuffer (Buffer
, EndBuffer
, Width
- Precision
, ' ', BytesPerOutputCharacter
);
716 Buffer
= BasePrintLibFillBuffer (Buffer
, EndBuffer
, 1, Prefix
, BytesPerOutputCharacter
);
718 Buffer
= BasePrintLibFillBuffer (Buffer
, EndBuffer
, Precision
- Count
, '0', BytesPerOutputCharacter
);
720 Buffer
= BasePrintLibFillBuffer (Buffer
, EndBuffer
, Precision
- Count
, ' ', BytesPerOutputCharacter
);
722 Buffer
= BasePrintLibFillBuffer (Buffer
, EndBuffer
, 1, Prefix
, BytesPerOutputCharacter
);
727 // Output the Prefix character if it is present
735 // Copy the string into the output buffer performing the required type conversions
737 while (Index
< Count
) {
738 ArgumentCharacter
= ((*ArgumentString
& 0xff) | (*(ArgumentString
+ 1) << 8)) & ArgumentMask
;
740 Buffer
= BasePrintLibFillBuffer (Buffer
, EndBuffer
, 1, ArgumentCharacter
, BytesPerOutputCharacter
);
741 ArgumentString
+= BytesPerArgumentCharacter
;
749 Buffer
= BasePrintLibFillBuffer (Buffer
, EndBuffer
, 1, ',', BytesPerOutputCharacter
);
756 // Pad after the string
758 if ((Flags
& (PAD_TO_WIDTH
| LEFT_JUSTIFY
)) == (PAD_TO_WIDTH
| LEFT_JUSTIFY
)) {
759 Buffer
= BasePrintLibFillBuffer (Buffer
, EndBuffer
, Width
- Precision
, ' ', BytesPerOutputCharacter
);
763 // Get the next character from the format string
765 Format
+= BytesPerFormatCharacter
;
768 // Get the next character from the format string
770 FormatCharacter
= ((*Format
& 0xff) | (*(Format
+ 1) << 8)) & FormatMask
;
774 // Null terminate the Unicode or ASCII string
776 BasePrintLibFillBuffer (Buffer
, EndBuffer
+ BytesPerOutputCharacter
, 1, 0, BytesPerOutputCharacter
);
778 // Make sure output buffer cannot contain more than PcdMaximumUnicodeStringLength
779 // Unicode characters if PcdMaximumUnicodeStringLength is not zero.
781 ASSERT ((((Flags
& OUTPUT_UNICODE
) == 0)) || (StrSize ((CHAR16
*) OriginalBuffer
) != 0));
783 // Make sure output buffer cannot contain more than PcdMaximumAsciiStringLength
784 // ASCII characters if PcdMaximumAsciiStringLength is not zero.
786 ASSERT ((((Flags
& OUTPUT_UNICODE
) != 0)) || (AsciiStrSize (OriginalBuffer
) != 0));
788 return ((Buffer
- OriginalBuffer
) / BytesPerOutputCharacter
);
792 Worker function that produces a Null-terminated string in an output buffer
793 based on a Null-terminated format string and variable argument list.
795 VSPrint function to process format and place the results in Buffer. Since a
796 VA_LIST is used this rountine allows the nesting of Vararg routines. Thus
797 this is the main print working routine
799 @param StartOfBuffer Character buffer to print the results of the parsing
801 @param BufferSize Maximum number of characters to put into buffer.
803 @param Flags Intial flags value.
804 Can only have FORMAT_UNICODE and OUTPUT_UNICODE set
805 @param FormatString Null-terminated format string.
806 @param ... The variable argument list.
808 @return Number of characters printed.
813 OUT CHAR8
*StartOfBuffer
,
816 IN CONST CHAR8
*FormatString
,
822 VA_START (Marker
, FormatString
);
823 return BasePrintLibVSPrint (StartOfBuffer
, BufferSize
, Flags
, FormatString
, Marker
);