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 @param Character Character to be placed into Buffer.
65 @param Increment Character increment in Buffer.
67 @return Buffer Buffer filled with the input Character.
71 BasePrintLibFillBuffer (
81 for (Index
= 0; Index
< Length
&& Buffer
< EndBuffer
; Index
++) {
82 *Buffer
= (CHAR8
) Character
;
83 *(Buffer
+ 1) = (CHAR8
) (Character
>> 8);
90 Internal function that convert a decimal number to a string in Buffer.
92 Print worker function that convert a decimal number to a string in Buffer.
94 @param Buffer Location to place the Unicode or ASCII string of Value.
95 @param Value Value to convert to a Decimal or Hexidecimal string in Buffer.
96 @param Radix Radix of the value
98 @return Number of characters printed.
102 BasePrintLibValueToString (
103 IN OUT CHAR8
*Buffer
,
112 // Loop to convert one digit at a time in reverse order
117 Value
= (INT64
)DivU64x32Remainder ((UINT64
)Value
, (UINT32
)Radix
, &Remainder
);
118 *(Buffer
++) = mHexStr
[Remainder
];
120 } while (Value
!= 0);
123 // the length of Buffer string converted from Value
129 Internal function that converts a decimal value to a Null-terminated string.
131 Converts the decimal number specified by Value to a Null-terminated
132 string specified by Buffer containing at most Width characters.
133 If Width is 0 then a width of MAXIMUM_VALUE_CHARACTERS is assumed.
134 The number of characters in Buffer is returned not including the Null-terminator.
135 If the conversion contains more than Width characters, then only the first
136 Width characters are returned, and the total number of characters
137 required to perform the conversion is returned.
138 Additional conversion parameters are specified in Flags.
139 The Flags bit LEFT_JUSTIFY is always ignored.
140 All conversions are left justified in Buffer.
141 If Width is 0, PREFIX_ZERO is ignored in Flags.
142 If COMMA_TYPE is set in Flags, then PREFIX_ZERO is ignored in Flags, and commas
143 are inserted every 3rd digit starting from the right.
144 If HEX_RADIX is set in Flags, then the output buffer will be formatted in hexadecimal format.
145 If Value is < 0 and HEX_RADIX is not set in Flags, 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.
150 If both COMMA_TYPE and HEX_RADIX are set in Flags, then ASSERT().
152 If Buffer is NULL, then ASSERT().
153 If unsupported bits are set in Flags, then ASSERT().
154 If Width >= MAXIMUM_VALUE_CHARACTERS, then ASSERT()
156 @param Buffer Pointer to the output buffer for the produced Null-terminated
158 @param Flags The bitmask of flags that specify left justification, zero pad,
160 @param Value The 64-bit signed value to convert to a string.
161 @param Width The maximum number of characters to place in Buffer, not including
163 @param Increment Character increment in Buffer.
165 @return The number of characters in Buffer not including the Null-terminator.
169 BasePrintLibConvertValueToString (
170 IN OUT CHAR8
*Buffer
,
177 CHAR8
*OriginalBuffer
;
179 CHAR8 ValueBuffer
[MAXIMUM_VALUE_CHARACTERS
];
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 HEX_RADIX are set, then ASSERT ()
198 ASSERT (((Flags
& COMMA_TYPE
) != 0 && (Flags
& RADIX_HEX
) != 0) == FALSE
);
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 Count
= BasePrintLibValueToString (ValueBuffer
, Value
, Radix
);
237 if ((Flags
& PREFIX_ZERO
) != 0) {
238 Buffer
= BasePrintLibFillBuffer (Buffer
, EndBuffer
, Width
- Count
, '0', Increment
);
242 // Print Comma type for every 3 characters
248 for (Index
= 0; Index
< Count
; Index
++) {
249 Buffer
= BasePrintLibFillBuffer (Buffer
, EndBuffer
, 1, ValueBuffer
[Count
- Index
], Increment
);
250 if ((Flags
& COMMA_TYPE
) != 0) {
254 if ((Index
+ 1) < Count
) {
255 Buffer
= BasePrintLibFillBuffer (Buffer
, EndBuffer
, 1, ',', Increment
);
262 // Print Null-terminator
264 BasePrintLibFillBuffer (Buffer
, EndBuffer
+ Increment
, 1, 0, Increment
);
266 return ((Buffer
- OriginalBuffer
) / Increment
);
270 Worker function that produces a Null-terminated string in an output buffer
271 based on a Null-terminated format string and a VA_LIST argument list.
273 VSPrint function to process format and place the results in Buffer. Since a
274 VA_LIST is used this rountine allows the nesting of Vararg routines. Thus
275 this is the main print working routine.
277 @param Buffer Character buffer to print the results of the parsing
279 @param BufferSize Maximum number of characters to put into buffer.
280 @param Flags Intial flags value.
281 Can only have FORMAT_UNICODE and OUTPUT_UNICODE set.
282 @param Format Null-terminated format string.
283 @param Marker Vararg list consumed by processing Format.
285 @return Number of characters printed not including the Null-terminator.
289 BasePrintLibVSPrint (
293 IN CONST CHAR8
*Format
,
297 CHAR8
*OriginalBuffer
;
299 CHAR8 ValueBuffer
[MAXIMUM_VALUE_CHARACTERS
];
300 UINTN BytesPerOutputCharacter
;
301 UINTN BytesPerFormatCharacter
;
303 UINTN FormatCharacter
;
307 CONST CHAR8
*ArgumentString
;
313 INTN BytesPerArgumentCharacter
;
314 UINTN ArgumentCharacter
;
322 RETURN_STATUS Status
;
324 if (BufferSize
== 0) {
327 ASSERT (Buffer
!= NULL
);
329 if ((Flags
& OUTPUT_UNICODE
) != 0) {
330 BytesPerOutputCharacter
= 2;
332 BytesPerOutputCharacter
= 1;
336 // Reserve space for the Null terminator.
339 OriginalBuffer
= Buffer
;
341 // Set the tag for the end of the input Buffer.
343 EndBuffer
= Buffer
+ BufferSize
* BytesPerOutputCharacter
;
345 if ((Flags
& FORMAT_UNICODE
) != 0) {
347 // Make sure format string cannot contain more than PcdMaximumUnicodeStringLength
348 // Unicode characters if PcdMaximumUnicodeStringLength is not zero.
350 ASSERT (StrSize ((CHAR16
*) Format
) != 0);
351 BytesPerFormatCharacter
= 2;
355 // Make sure format string cannot contain more than PcdMaximumAsciiStringLength
356 // Ascii characters if PcdMaximumAsciiStringLength is not zero.
358 ASSERT (AsciiStrSize (Format
) != 0);
359 BytesPerFormatCharacter
= 1;
366 // Get the first character from the format string
368 FormatCharacter
= ((*Format
& 0xff) | (*(Format
+ 1) << 8)) & FormatMask
;
371 // Loop until the end of the format string is reached or the output buffer is full
373 while (FormatCharacter
!= 0 && Buffer
< EndBuffer
) {
375 // Clear all the flag bits except those that may have been passed in
377 Flags
&= (OUTPUT_UNICODE
| FORMAT_UNICODE
);
380 // Set the default width to zero, and the default precision to 1
390 switch (FormatCharacter
) {
393 // Parse Flags and Width
395 for (Done
= FALSE
; !Done
; ) {
396 Format
+= BytesPerFormatCharacter
;
397 FormatCharacter
= ((*Format
& 0xff) | (*(Format
+ 1) << 8)) & FormatMask
;
398 switch (FormatCharacter
) {
403 Flags
|= LEFT_JUSTIFY
;
406 Flags
|= PREFIX_SIGN
;
409 Flags
|= PREFIX_BLANK
;
419 if ((Flags
& PRECISION
) == 0) {
420 Flags
|= PAD_TO_WIDTH
;
421 Width
= VA_ARG (Marker
, UINTN
);
423 Precision
= VA_ARG (Marker
, UINTN
);
427 if ((Flags
& PRECISION
) == 0) {
428 Flags
|= PREFIX_ZERO
;
439 for (Count
= 0; ((FormatCharacter
>= '0') && (FormatCharacter
<= '9')); ){
440 Count
= (Count
* 10) + FormatCharacter
- '0';
441 Format
+= BytesPerFormatCharacter
;
442 FormatCharacter
= ((*Format
& 0xff) | (*(Format
+ 1) << 8)) & FormatMask
;
444 Format
-= BytesPerFormatCharacter
;
445 if ((Flags
& PRECISION
) == 0) {
446 Flags
|= PAD_TO_WIDTH
;
455 // Make no output if Format string terminates unexpectedly when
456 // looking up for flag, width, precision and type.
458 Format
-= BytesPerFormatCharacter
;
461 // break skipped on purpose.
470 // Handle each argument type
472 switch (FormatCharacter
) {
475 // Flag space, +, 0, L & l are invalid for type p.
477 Flags
&= ~(PREFIX_BLANK
| PREFIX_SIGN
| PREFIX_ZERO
| LONG_TYPE
);
478 if (sizeof (VOID
*) > 4) {
482 Flags
|= PREFIX_ZERO
;
484 // break skipped on purpose
489 // break skipped on purpose
492 if ((Flags
& LONG_TYPE
) == 0) {
493 Value
= (VA_ARG (Marker
, int));
495 Value
= VA_ARG (Marker
, INT64
);
497 if ((Flags
& PREFIX_BLANK
) != 0) {
500 if ((Flags
& PREFIX_SIGN
) != 0) {
503 if ((Flags
& COMMA_TYPE
) != 0) {
506 if ((Flags
& RADIX_HEX
) == 0) {
509 Flags
&= (~PREFIX_ZERO
);
513 Flags
|= PREFIX_SIGN
;
520 if ((Flags
& LONG_TYPE
) == 0 && Value
< 0) {
521 Value
= (unsigned int)Value
;
525 // Convert Value to a reversed string
527 Count
= BasePrintLibValueToString (ValueBuffer
, Value
, Radix
);
528 if (Value
== 0 && Precision
== 0) {
531 ArgumentString
= (CHAR8
*)ValueBuffer
+ Count
;
537 if (Comma
&& Count
!= 0) {
538 Count
+= ((Count
- 1) / 3);
544 Flags
|= ARGUMENT_REVERSED
;
546 if ((Flags
& PREFIX_ZERO
) != 0) {
547 if ((Flags
& LEFT_JUSTIFY
) == 0) {
548 if ((Flags
& PAD_TO_WIDTH
) != 0) {
549 if ((Flags
& PRECISION
) == 0) {
559 Flags
|= ARGUMENT_UNICODE
;
561 // break skipped on purpose
564 ArgumentString
= (CHAR8
*)VA_ARG (Marker
, CHAR8
*);
565 if (ArgumentString
== NULL
) {
566 Flags
&= (~ARGUMENT_UNICODE
);
567 ArgumentString
= "<null string>";
570 // Set the default precision for string to be zero if not specified.
572 if ((Flags
& PRECISION
) == 0) {
578 Character
= VA_ARG (Marker
, UINTN
) & 0xffff;
579 ArgumentString
= (CHAR8
*)&Character
;
580 Flags
|= ARGUMENT_UNICODE
;
584 TmpGuid
= VA_ARG (Marker
, GUID
*);
585 if (TmpGuid
== NULL
) {
586 ArgumentString
= "<null guid>";
590 MAXIMUM_VALUE_CHARACTERS
,
592 "%08x-%04x-%04x-%02x%02x-%02x%02x%02x%02x%02x%02x",
605 ArgumentString
= ValueBuffer
;
610 TmpTime
= VA_ARG (Marker
, TIME
*);
611 if (TmpTime
== NULL
) {
612 ArgumentString
= "<null time>";
616 MAXIMUM_VALUE_CHARACTERS
,
618 "%02d/%02d/%04d %02d:%02d",
625 ArgumentString
= ValueBuffer
;
630 Status
= VA_ARG (Marker
, RETURN_STATUS
);
631 ArgumentString
= ValueBuffer
;
632 if (RETURN_ERROR (Status
)) {
636 Index
= Status
& ~MAX_BIT
;
637 if (Index
> 0 && Index
<= ERROR_STATUS_NUMBER
) {
638 ArgumentString
= mStatusString
[Index
+ WARNING_STATUS_NUMBER
];
642 if (Index
<= WARNING_STATUS_NUMBER
) {
643 ArgumentString
= mStatusString
[Index
];
646 if (ArgumentString
== ValueBuffer
) {
647 BasePrintLibSPrint ((CHAR8
*) ValueBuffer
, MAXIMUM_VALUE_CHARACTERS
, 0, "%08X", Status
);
652 ArgumentString
= "\n\r";
658 // if the type is '%' or unknown, then print it to the screen
660 ArgumentString
= (CHAR8
*)&FormatCharacter
;
661 Flags
|= ARGUMENT_UNICODE
;
667 ArgumentString
= "\n\r";
671 ArgumentString
= (CHAR8
*)&FormatCharacter
;
672 Flags
|= ARGUMENT_UNICODE
;
677 // Retrieve the ArgumentString attriubutes
679 if ((Flags
& ARGUMENT_UNICODE
) != 0) {
680 ArgumentMask
= 0xffff;
681 BytesPerArgumentCharacter
= 2;
684 BytesPerArgumentCharacter
= 1;
686 if ((Flags
& ARGUMENT_REVERSED
) != 0) {
687 BytesPerArgumentCharacter
= -BytesPerArgumentCharacter
;
690 // Compute the number of characters in ArgumentString and store it in Count
691 // ArgumentString is either null-terminated, or it contains Precision characters
693 for (Count
= 0; Count
< Precision
|| ((Flags
& PRECISION
) == 0); Count
++) {
694 ArgumentCharacter
= ((ArgumentString
[Count
* BytesPerArgumentCharacter
] & 0xff) | ((ArgumentString
[Count
* BytesPerArgumentCharacter
+ 1]) << 8)) & ArgumentMask
;
695 if (ArgumentCharacter
== 0) {
701 if (Precision
< Count
) {
706 // Pad before the string
708 if ((Flags
& (PAD_TO_WIDTH
| LEFT_JUSTIFY
)) == (PAD_TO_WIDTH
)) {
709 Buffer
= BasePrintLibFillBuffer (Buffer
, EndBuffer
, Width
- Precision
, ' ', BytesPerOutputCharacter
);
714 Buffer
= BasePrintLibFillBuffer (Buffer
, EndBuffer
, 1, Prefix
, BytesPerOutputCharacter
);
716 Buffer
= BasePrintLibFillBuffer (Buffer
, EndBuffer
, Precision
- Count
, '0', BytesPerOutputCharacter
);
718 Buffer
= BasePrintLibFillBuffer (Buffer
, EndBuffer
, Precision
- Count
, ' ', BytesPerOutputCharacter
);
720 Buffer
= BasePrintLibFillBuffer (Buffer
, EndBuffer
, 1, Prefix
, BytesPerOutputCharacter
);
725 // Output the Prefix character if it is present
733 // Copy the string into the output buffer performing the required type conversions
735 while (Index
< Count
) {
736 ArgumentCharacter
= ((*ArgumentString
& 0xff) | (*(ArgumentString
+ 1) << 8)) & ArgumentMask
;
738 Buffer
= BasePrintLibFillBuffer (Buffer
, EndBuffer
, 1, ArgumentCharacter
, BytesPerOutputCharacter
);
739 ArgumentString
+= BytesPerArgumentCharacter
;
747 Buffer
= BasePrintLibFillBuffer (Buffer
, EndBuffer
, 1, ',', BytesPerOutputCharacter
);
754 // Pad after the string
756 if ((Flags
& (PAD_TO_WIDTH
| LEFT_JUSTIFY
)) == (PAD_TO_WIDTH
| LEFT_JUSTIFY
)) {
757 Buffer
= BasePrintLibFillBuffer (Buffer
, EndBuffer
, Width
- Precision
, ' ', BytesPerOutputCharacter
);
761 // Get the next character from the format string
763 Format
+= BytesPerFormatCharacter
;
766 // Get the next character from the format string
768 FormatCharacter
= ((*Format
& 0xff) | (*(Format
+ 1) << 8)) & FormatMask
;
772 // Null terminate the Unicode or ASCII string
774 BasePrintLibFillBuffer (Buffer
, EndBuffer
+ BytesPerOutputCharacter
, 1, 0, BytesPerOutputCharacter
);
776 // Make sure output buffer cannot contain more than PcdMaximumUnicodeStringLength
777 // Unicode characters if PcdMaximumUnicodeStringLength is not zero.
779 ASSERT ((((Flags
& OUTPUT_UNICODE
) == 0)) || (StrSize ((CHAR16
*) OriginalBuffer
) != 0));
781 // Make sure output buffer cannot contain more than PcdMaximumAsciiStringLength
782 // ASCII characters if PcdMaximumAsciiStringLength is not zero.
784 ASSERT ((((Flags
& OUTPUT_UNICODE
) != 0)) || (AsciiStrSize (OriginalBuffer
) != 0));
786 return ((Buffer
- OriginalBuffer
) / BytesPerOutputCharacter
);
790 Worker function that produces a Null-terminated string in an output buffer
791 based on a Null-terminated format string and variable argument list.
793 VSPrint function to process format and place the results in Buffer. Since a
794 VA_LIST is used this rountine allows the nesting of Vararg routines. Thus
795 this is the main print working routine.
797 @param StartOfBuffer Character buffer to print the results of the parsing
799 @param BufferSize Maximum number of characters to put into buffer.
801 @param Flags Intial flags value.
802 Can only have FORMAT_UNICODE and OUTPUT_UNICODE set
803 @param FormatString Null-terminated format string.
804 @param ... The variable argument list.
806 @return Number of characters printed not including the Null-terminator.
811 OUT CHAR8
*StartOfBuffer
,
814 IN CONST CHAR8
*FormatString
,
820 VA_START (Marker
, FormatString
);
821 return BasePrintLibVSPrint (StartOfBuffer
, BufferSize
, Flags
, FormatString
, Marker
);