PrintLibInternal.c@ 62180

最後變更在這個檔案從62180是 58466,由 vboxsync 提交於 9 年前
EFI/Firmware: Merged in the svn:eol-style, svn:mime-type and trailing whitespace cleanup that was done after the initial UDK2014.SP1 import: svn merge ^{/vendor/edk2/UDK2014.SP1}/vendor/edk2/current .
屬性 svn:eol-style 設為 `native`
檔案大小: 32.4 KB

行
1	/** @file
2	Print Library internal worker functions.
3
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.
9
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.
12
13	**/
14
15	#include "PrintLibInternal.h"
16
17	#define WARNING_STATUS_NUMBER 5
18	#define ERROR_STATUS_NUMBER 33
19
20	GLOBAL_REMOVE_IF_UNREFERENCED CONST CHAR8 mHexStr[] = {'0','1','2','3','4','5','6','7','8','9','A','B','C','D','E','F'};
21
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	"Warning Stale Data", // RETURN_WARN_STALE_DATA = 5
29	"Load Error", // RETURN_LOAD_ERROR = 1 \| MAX_BIT
30	"Invalid Parameter", // RETURN_INVALID_PARAMETER = 2 \| MAX_BIT
31	"Unsupported", // RETURN_UNSUPPORTED = 3 \| MAX_BIT
32	"Bad Buffer Size", // RETURN_BAD_BUFFER_SIZE = 4 \| MAX_BIT
33	"Buffer Too Small", // RETURN_BUFFER_TOO_SMALL, = 5 \| MAX_BIT
34	"Not Ready", // RETURN_NOT_READY = 6 \| MAX_BIT
35	"Device Error", // RETURN_DEVICE_ERROR = 7 \| MAX_BIT
36	"Write Protected", // RETURN_WRITE_PROTECTED = 8 \| MAX_BIT
37	"Out of Resources", // RETURN_OUT_OF_RESOURCES = 9 \| MAX_BIT
38	"Volume Corrupt", // RETURN_VOLUME_CORRUPTED = 10 \| MAX_BIT
39	"Volume Full", // RETURN_VOLUME_FULL = 11 \| MAX_BIT
40	"No Media", // RETURN_NO_MEDIA = 12 \| MAX_BIT
41	"Media changed", // RETURN_MEDIA_CHANGED = 13 \| MAX_BIT
42	"Not Found", // RETURN_NOT_FOUND = 14 \| MAX_BIT
43	"Access Denied", // RETURN_ACCESS_DENIED = 15 \| MAX_BIT
44	"No Response", // RETURN_NO_RESPONSE = 16 \| MAX_BIT
45	"No mapping", // RETURN_NO_MAPPING = 17 \| MAX_BIT
46	"Time out", // RETURN_TIMEOUT = 18 \| MAX_BIT
47	"Not started", // RETURN_NOT_STARTED = 19 \| MAX_BIT
48	"Already started", // RETURN_ALREADY_STARTED = 20 \| MAX_BIT
49	"Aborted", // RETURN_ABORTED = 21 \| MAX_BIT
50	"ICMP Error", // RETURN_ICMP_ERROR = 22 \| MAX_BIT
51	"TFTP Error", // RETURN_TFTP_ERROR = 23 \| MAX_BIT
52	"Protocol Error", // RETURN_PROTOCOL_ERROR = 24 \| MAX_BIT
53	"Incompatible Version", // RETURN_INCOMPATIBLE_VERSION = 25 \| MAX_BIT
54	"Security Violation", // RETURN_SECURITY_VIOLATION = 26 \| MAX_BIT
55	"CRC Error", // RETURN_CRC_ERROR = 27 \| MAX_BIT
56	"End of Media", // RETURN_END_OF_MEDIA = 28 \| MAX_BIT
57	"Reserved (29)", // RESERVED = 29 \| MAX_BIT
58	"Reserved (30)", // RESERVED = 30 \| MAX_BIT
59	"End of File", // RETURN_END_OF_FILE = 31 \| MAX_BIT
60	"Invalid Language", // RETURN_INVALID_LANGUAGE = 32 \| MAX_BIT
61	"Compromised Data" // RETURN_COMPROMISED_DATA = 33 \| MAX_BIT
62	};
63
64
65	/**
66	Internal function that places the character into the Buffer.
67
68	Internal function that places ASCII or Unicode character into the Buffer.
69
70	@param Buffer The buffer to place the Unicode or ASCII string.
71	@param EndBuffer The end of the input Buffer. No characters will be
72	placed after that.
73	@param Length The count of character to be placed into Buffer.
74	(Negative value indicates no buffer fill.)
75	@param Character The character to be placed into Buffer.
76	@param Increment The character increment in Buffer.
77
78	@return Buffer.
79
80	**/
81	CHAR8 *
82	BasePrintLibFillBuffer (
83	OUT CHAR8 *Buffer,
84	IN CHAR8 *EndBuffer,
85	IN INTN Length,
86	IN UINTN Character,
87	IN INTN Increment
88	)
89	{
90	INTN Index;
91
92	for (Index = 0; Index < Length && Buffer < EndBuffer; Index++) {
93	*Buffer = (CHAR8) Character;
94	if (Increment != 1) {
95	*(Buffer + 1) = (CHAR8)(Character >> 8);
96	}
97	Buffer += Increment;
98	}
99
100	return Buffer;
101	}
102
103	/**
104	Internal function that convert a number to a string in Buffer.
105
106	Print worker function that converts a decimal or hexadecimal number to an ASCII string in Buffer.
107
108	@param Buffer Location to place the ASCII string of Value.
109	@param Value The value to convert to a Decimal or Hexadecimal string in Buffer.
110	@param Radix Radix of the value
111
112	@return A pointer to the end of buffer filled with ASCII string.
113
114	**/
115	CHAR8 *
116	BasePrintLibValueToString (
117	IN OUT CHAR8 *Buffer,
118	IN INT64 Value,
119	IN UINTN Radix
120	)
121	{
122	UINT32 Remainder;
123
124	//
125	// Loop to convert one digit at a time in reverse order
126	//
127	*Buffer = 0;
128	do {
129	Value = (INT64)DivU64x32Remainder ((UINT64)Value, (UINT32)Radix, &Remainder);
130	*(++Buffer) = mHexStr[Remainder];
131	} while (Value != 0);
132
133	//
134	// Return pointer of the end of filled buffer.
135	//
136	return Buffer;
137	}
138
139	/**
140	Internal function that converts a decimal value to a Null-terminated string.
141
142	Converts the decimal number specified by Value to a Null-terminated
143	string specified by Buffer containing at most Width characters.
144	If Width is 0 then a width of MAXIMUM_VALUE_CHARACTERS is assumed.
145	The total number of characters placed in Buffer is returned.
146	If the conversion contains more than Width characters, then only the first
147	Width characters are returned, and the total number of characters
148	required to perform the conversion is returned.
149	Additional conversion parameters are specified in Flags.
150	The Flags bit LEFT_JUSTIFY is always ignored.
151	All conversions are left justified in Buffer.
152	If Width is 0, PREFIX_ZERO is ignored in Flags.
153	If COMMA_TYPE is set in Flags, then PREFIX_ZERO is ignored in Flags, and commas
154	are inserted every 3rd digit starting from the right.
155	If Value is < 0, then the fist character in Buffer is a '-'.
156	If PREFIX_ZERO is set in Flags and PREFIX_ZERO is not being ignored,
157	then Buffer is padded with '0' characters so the combination of the optional '-'
158	sign character, '0' characters, digit characters for Value, and the Null-terminator
159	add up to Width characters.
160
161	If Buffer is NULL, then ASSERT().
162	If unsupported bits are set in Flags, then ASSERT().
163	If Width >= MAXIMUM_VALUE_CHARACTERS, then ASSERT()
164
165	@param Buffer The pointer to the output buffer for the produced Null-terminated
166	string.
167	@param Flags The bitmask of flags that specify left justification, zero pad,
168	and commas.
169	@param Value The 64-bit signed value to convert to a string.
170	@param Width The maximum number of characters to place in Buffer, not including
171	the Null-terminator.
172	@param Increment The character increment in Buffer.
173
174	@return Total number of characters required to perform the conversion.
175
176	**/
177	UINTN
178	BasePrintLibConvertValueToString (
179	IN OUT CHAR8 *Buffer,
180	IN UINTN Flags,
181	IN INT64 Value,
182	IN UINTN Width,
183	IN UINTN Increment
184	)
185	{
186	CHAR8 *OriginalBuffer;
187	CHAR8 *EndBuffer;
188	CHAR8 ValueBuffer[MAXIMUM_VALUE_CHARACTERS];
189	CHAR8 *ValueBufferPtr;
190	UINTN Count;
191	UINTN Digits;
192	UINTN Index;
193	UINTN Radix;
194
195	//
196	// Make sure Buffer is not NULL and Width < MAXIMUM
197	//
198	ASSERT (Buffer != NULL);
199	ASSERT (Width < MAXIMUM_VALUE_CHARACTERS);
200	//
201	// Make sure Flags can only contain supported bits.
202	//
203	ASSERT ((Flags & ~(LEFT_JUSTIFY \| COMMA_TYPE \| PREFIX_ZERO \| RADIX_HEX)) == 0);
204
205	//
206	// If both COMMA_TYPE and RADIX_HEX are set, then ASSERT ()
207	//
208	ASSERT (((Flags & COMMA_TYPE) == 0) \|\| ((Flags & RADIX_HEX) == 0));
209
210	OriginalBuffer = Buffer;
211
212	//
213	// Width is 0 or COMMA_TYPE is set, PREFIX_ZERO is ignored.
214	//
215	if (Width == 0 \|\| (Flags & COMMA_TYPE) != 0) {
216	Flags &= ~((UINTN) PREFIX_ZERO);
217	}
218	//
219	// If Width is 0 then a width of MAXIMUM_VALUE_CHARACTERS is assumed.
220	//
221	if (Width == 0) {
222	Width = MAXIMUM_VALUE_CHARACTERS - 1;
223	}
224	//
225	// Set the tag for the end of the input Buffer.
226	//
227	EndBuffer = Buffer + Width * Increment;
228
229	//
230	// Convert decimal negative
231	//
232	if ((Value < 0) && ((Flags & RADIX_HEX) == 0)) {
233	Value = -Value;
234	Buffer = BasePrintLibFillBuffer (Buffer, EndBuffer, 1, '-', Increment);
235	Width--;
236	}
237
238	//
239	// Count the length of the value string.
240	//
241	Radix = ((Flags & RADIX_HEX) == 0)? 10 : 16;
242	ValueBufferPtr = BasePrintLibValueToString (ValueBuffer, Value, Radix);
243	Count = ValueBufferPtr - ValueBuffer;
244
245	//
246	// Append Zero
247	//
248	if ((Flags & PREFIX_ZERO) != 0) {
249	Buffer = BasePrintLibFillBuffer (Buffer, EndBuffer, Width - Count, '0', Increment);
250	}
251
252	//
253	// Print Comma type for every 3 characters
254	//
255	Digits = Count % 3;
256	if (Digits != 0) {
257	Digits = 3 - Digits;
258	}
259	for (Index = 0; Index < Count; Index++) {
260	Buffer = BasePrintLibFillBuffer (Buffer, EndBuffer, 1, *ValueBufferPtr--, Increment);
261	if ((Flags & COMMA_TYPE) != 0) {
262	Digits++;
263	if (Digits == 3) {
264	Digits = 0;
265	if ((Index + 1) < Count) {
266	Buffer = BasePrintLibFillBuffer (Buffer, EndBuffer, 1, ',', Increment);
267	}
268	}
269	}
270	}
271
272	//
273	// Print Null-terminator
274	//
275	BasePrintLibFillBuffer (Buffer, EndBuffer + Increment, 1, 0, Increment);
276
277	return ((Buffer - OriginalBuffer) / Increment);
278	}
279
280	/**
281	Worker function that produces a Null-terminated string in an output buffer
282	based on a Null-terminated format string and a VA_LIST argument list.
283
284	VSPrint function to process format and place the results in Buffer. Since a
285	VA_LIST is used this routine allows the nesting of Vararg routines. Thus
286	this is the main print working routine.
287
288	If COUNT_ONLY_NO_PRINT is set in Flags, Buffer will not be modified at all.
289
290	@param[out] Buffer The character buffer to print the results of the
291	parsing of Format into.
292	@param[in] BufferSize The maximum number of characters to put into
293	buffer.
294	@param[in] Flags Initial flags value.
295	Can only have FORMAT_UNICODE, OUTPUT_UNICODE,
296	and COUNT_ONLY_NO_PRINT set.
297	@param[in] Format A Null-terminated format string.
298	@param[in] VaListMarker VA_LIST style variable argument list consumed by
299	processing Format.
300	@param[in] BaseListMarker BASE_LIST style variable argument list consumed
301	by processing Format.
302
303	@return The number of characters printed not including the Null-terminator.
304	If COUNT_ONLY_NO_PRINT was set returns the same, but without any
305	modification to Buffer.
306
307	**/
308	UINTN
309	BasePrintLibSPrintMarker (
310	OUT CHAR8 *Buffer,
311	IN UINTN BufferSize,
312	IN UINTN Flags,
313	IN CONST CHAR8 *Format,
314	IN VA_LIST VaListMarker, OPTIONAL
315	IN BASE_LIST BaseListMarker OPTIONAL
316	)
317	{
318	CHAR8 *OriginalBuffer;
319	CHAR8 *EndBuffer;
320	CHAR8 ValueBuffer[MAXIMUM_VALUE_CHARACTERS];
321	UINT32 BytesPerOutputCharacter;
322	UINTN BytesPerFormatCharacter;
323	UINTN FormatMask;
324	UINTN FormatCharacter;
325	UINTN Width;
326	UINTN Precision;
327	INT64 Value;
328	CONST CHAR8 *ArgumentString;
329	UINTN Character;
330	GUID *TmpGuid;
331	TIME *TmpTime;
332	UINTN Count;
333	UINTN ArgumentMask;
334	INTN BytesPerArgumentCharacter;
335	UINTN ArgumentCharacter;
336	BOOLEAN Done;
337	UINTN Index;
338	CHAR8 Prefix;
339	BOOLEAN ZeroPad;
340	BOOLEAN Comma;
341	UINTN Digits;
342	UINTN Radix;
343	RETURN_STATUS Status;
344	UINT32 GuidData1;
345	UINT16 GuidData2;
346	UINT16 GuidData3;
347	UINTN LengthToReturn;
348
349	//
350	// If you change this code be sure to match the 2 versions of this function.
351	// Nearly identical logic is found in the BasePrintLib and
352	// DxePrintLibPrint2Protocol (both PrintLib instances).
353	//
354
355	if ((Flags & COUNT_ONLY_NO_PRINT) != 0) {
356	if (BufferSize == 0) {
357	Buffer = NULL;
358	}
359	} else {
360	//
361	// We can run without a Buffer for counting only.
362	//
363	if (BufferSize == 0) {
364	return 0;
365	}
366	ASSERT (Buffer != NULL);
367	}
368
369	if ((Flags & OUTPUT_UNICODE) != 0) {
370	BytesPerOutputCharacter = 2;
371	} else {
372	BytesPerOutputCharacter = 1;
373	}
374
375	LengthToReturn = 0;
376	EndBuffer = NULL;
377	OriginalBuffer = NULL;
378
379	//
380	// Reserve space for the Null terminator.
381	//
382	if (Buffer != NULL) {
383	BufferSize--;
384	OriginalBuffer = Buffer;
385
386	//
387	// Set the tag for the end of the input Buffer.
388	//
389	EndBuffer = Buffer + BufferSize * BytesPerOutputCharacter;
390	}
391
392	if ((Flags & FORMAT_UNICODE) != 0) {
393	//
394	// Make sure format string cannot contain more than PcdMaximumUnicodeStringLength
395	// Unicode characters if PcdMaximumUnicodeStringLength is not zero.
396	//
397	ASSERT (StrSize ((CHAR16 *) Format) != 0);
398	BytesPerFormatCharacter = 2;
399	FormatMask = 0xffff;
400	} else {
401	//
402	// Make sure format string cannot contain more than PcdMaximumAsciiStringLength
403	// Ascii characters if PcdMaximumAsciiStringLength is not zero.
404	//
405	ASSERT (AsciiStrSize (Format) != 0);
406	BytesPerFormatCharacter = 1;
407	FormatMask = 0xff;
408	}
409
410	//
411	// Get the first character from the format string
412	//
413	FormatCharacter = ((Format & 0xff) \| ((Format + 1) << 8)) & FormatMask;
414
415	//
416	// Loop until the end of the format string is reached or the output buffer is full
417	//
418	while (FormatCharacter != 0) {
419	if ((Buffer != NULL) && (Buffer >= EndBuffer)) {
420	break;
421	}
422	//
423	// Clear all the flag bits except those that may have been passed in
424	//
425	Flags &= (UINTN) (OUTPUT_UNICODE \| FORMAT_UNICODE \| COUNT_ONLY_NO_PRINT);
426
427	//
428	// Set the default width to zero, and the default precision to 1
429	//
430	Width = 0;
431	Precision = 1;
432	Prefix = 0;
433	Comma = FALSE;
434	ZeroPad = FALSE;
435	Count = 0;
436	Digits = 0;
437
438	switch (FormatCharacter) {
439	case '%':
440	//
441	// Parse Flags and Width
442	//
443	for (Done = FALSE; !Done; ) {
444	Format += BytesPerFormatCharacter;
445	FormatCharacter = ((Format & 0xff) \| ((Format + 1) << 8)) & FormatMask;
446	switch (FormatCharacter) {
447	case '.':
448	Flags \|= PRECISION;
449	break;
450	case '-':
451	Flags \|= LEFT_JUSTIFY;
452	break;
453	case '+':
454	Flags \|= PREFIX_SIGN;
455	break;
456	case ' ':
457	Flags \|= PREFIX_BLANK;
458	break;
459	case ',':
460	Flags \|= COMMA_TYPE;
461	break;
462	case 'L':
463	case 'l':
464	Flags \|= LONG_TYPE;
465	break;
466	case '*':
467	if ((Flags & PRECISION) == 0) {
468	Flags \|= PAD_TO_WIDTH;
469	if (BaseListMarker == NULL) {
470	Width = VA_ARG (VaListMarker, UINTN);
471	} else {
472	Width = BASE_ARG (BaseListMarker, UINTN);
473	}
474	} else {
475	if (BaseListMarker == NULL) {
476	Precision = VA_ARG (VaListMarker, UINTN);
477	} else {
478	Precision = BASE_ARG (BaseListMarker, UINTN);
479	}
480	}
481	break;
482	case '0':
483	if ((Flags & PRECISION) == 0) {
484	Flags \|= PREFIX_ZERO;
485	}
486	case '1':
487	case '2':
488	case '3':
489	case '4':
490	case '5':
491	case '6':
492	case '7':
493	case '8':
494	case '9':
495	for (Count = 0; ((FormatCharacter >= '0') && (FormatCharacter <= '9')); ){
496	Count = (Count * 10) + FormatCharacter - '0';
497	Format += BytesPerFormatCharacter;
498	FormatCharacter = ((Format & 0xff) \| ((Format + 1) << 8)) & FormatMask;
499	}
500	Format -= BytesPerFormatCharacter;
501	if ((Flags & PRECISION) == 0) {
502	Flags \|= PAD_TO_WIDTH;
503	Width = Count;
504	} else {
505	Precision = Count;
506	}
507	break;
508
509	case '\0':
510	//
511	// Make no output if Format string terminates unexpectedly when
512	// looking up for flag, width, precision and type.
513	//
514	Format -= BytesPerFormatCharacter;
515	Precision = 0;
516	//
517	// break skipped on purpose.
518	//
519	default:
520	Done = TRUE;
521	break;
522	}
523	}
524
525	//
526	// Handle each argument type
527	//
528	switch (FormatCharacter) {
529	case 'p':
530	//
531	// Flag space, +, 0, L & l are invalid for type p.
532	//
533	Flags &= ~((UINTN) (PREFIX_BLANK \| PREFIX_SIGN \| PREFIX_ZERO \| LONG_TYPE));
534	if (sizeof (VOID *) > 4) {
535	Flags \|= LONG_TYPE;
536	}
537	//
538	// break skipped on purpose
539	//
540	case 'X':
541	Flags \|= PREFIX_ZERO;
542	//
543	// break skipped on purpose
544	//
545	case 'x':
546	Flags \|= RADIX_HEX;
547	//
548	// break skipped on purpose
549	//
550	case 'd':
551	if ((Flags & LONG_TYPE) == 0) {
552	//
553	// 'd','x', and 'X' that are not preceded by 'l' or 'L' are assumed to be type "int".
554	// This assumption is made so the format string definition is compatible with the ANSI C
555	// Specification for formatted strings. It is recommended that the Base Types be used
556	// everywhere, but in this one case, compliance with ANSI C is more important, and
557	// provides an implementation that is compatible with that largest possible set of CPU
558	// architectures. This is why the type "int" is used in this one case.
559	//
560	if (BaseListMarker == NULL) {
561	Value = VA_ARG (VaListMarker, int);
562	} else {
563	Value = BASE_ARG (BaseListMarker, int);
564	}
565	} else {
566	if (BaseListMarker == NULL) {
567	Value = VA_ARG (VaListMarker, INT64);
568	} else {
569	Value = BASE_ARG (BaseListMarker, INT64);
570	}
571	}
572	if ((Flags & PREFIX_BLANK) != 0) {
573	Prefix = ' ';
574	}
575	if ((Flags & PREFIX_SIGN) != 0) {
576	Prefix = '+';
577	}
578	if ((Flags & COMMA_TYPE) != 0) {
579	Comma = TRUE;
580	}
581	if ((Flags & RADIX_HEX) == 0) {
582	Radix = 10;
583	if (Comma) {
584	Flags &= ~((UINTN) PREFIX_ZERO);
585	Precision = 1;
586	}
587	if (Value < 0) {
588	Flags \|= PREFIX_SIGN;
589	Prefix = '-';
590	Value = -Value;
591	}
592	} else {
593	Radix = 16;
594	Comma = FALSE;
595	if ((Flags & LONG_TYPE) == 0 && Value < 0) {
596	//
597	// 'd','x', and 'X' that are not preceded by 'l' or 'L' are assumed to be type "int".
598	// This assumption is made so the format string definition is compatible with the ANSI C
599	// Specification for formatted strings. It is recommended that the Base Types be used
600	// everywhere, but in this one case, compliance with ANSI C is more important, and
601	// provides an implementation that is compatible with that largest possible set of CPU
602	// architectures. This is why the type "unsigned int" is used in this one case.
603	//
604	Value = (unsigned int)Value;
605	}
606	}
607	//
608	// Convert Value to a reversed string
609	//
610	Count = BasePrintLibValueToString (ValueBuffer, Value, Radix) - ValueBuffer;
611	if (Value == 0 && Precision == 0) {
612	Count = 0;
613	}
614	ArgumentString = (CHAR8 *)ValueBuffer + Count;
615
616	Digits = Count % 3;
617	if (Digits != 0) {
618	Digits = 3 - Digits;
619	}
620	if (Comma && Count != 0) {
621	Count += ((Count - 1) / 3);
622	}
623	if (Prefix != 0) {
624	Count++;
625	Precision++;
626	}
627	Flags \|= ARGUMENT_REVERSED;
628	ZeroPad = TRUE;
629	if ((Flags & PREFIX_ZERO) != 0) {
630	if ((Flags & LEFT_JUSTIFY) == 0) {
631	if ((Flags & PAD_TO_WIDTH) != 0) {
632	if ((Flags & PRECISION) == 0) {
633	Precision = Width;
634	}
635	}
636	}
637	}
638	break;
639
640	case 's':
641	case 'S':
642	Flags \|= ARGUMENT_UNICODE;
643	//
644	// break skipped on purpose
645	//
646	case 'a':
647	if (BaseListMarker == NULL) {
648	ArgumentString = VA_ARG (VaListMarker, CHAR8 *);
649	} else {
650	ArgumentString = BASE_ARG (BaseListMarker, CHAR8 *);
651	}
652	if (ArgumentString == NULL) {
653	Flags &= ~((UINTN) ARGUMENT_UNICODE);
654	ArgumentString = "<null string>";
655	}
656	//
657	// Set the default precision for string to be zero if not specified.
658	//
659	if ((Flags & PRECISION) == 0) {
660	Precision = 0;
661	}
662	break;
663
664	case 'c':
665	if (BaseListMarker == NULL) {
666	Character = VA_ARG (VaListMarker, UINTN) & 0xffff;
667	} else {
668	Character = BASE_ARG (BaseListMarker, UINTN) & 0xffff;
669	}
670	ArgumentString = (CHAR8 *)&Character;
671	Flags \|= ARGUMENT_UNICODE;
672	break;
673
674	case 'g':
675	if (BaseListMarker == NULL) {
676	TmpGuid = VA_ARG (VaListMarker, GUID *);
677	} else {
678	TmpGuid = BASE_ARG (BaseListMarker, GUID *);
679	}
680	if (TmpGuid == NULL) {
681	ArgumentString = "<null guid>";
682	} else {
683	GuidData1 = ReadUnaligned32 (&(TmpGuid->Data1));
684	GuidData2 = ReadUnaligned16 (&(TmpGuid->Data2));
685	GuidData3 = ReadUnaligned16 (&(TmpGuid->Data3));
686	BasePrintLibSPrint (
687	ValueBuffer,
688	MAXIMUM_VALUE_CHARACTERS,
689	0,
690	"%08x-%04x-%04x-%02x%02x-%02x%02x%02x%02x%02x%02x",
691	GuidData1,
692	GuidData2,
693	GuidData3,
694	TmpGuid->Data4[0],
695	TmpGuid->Data4[1],
696	TmpGuid->Data4[2],
697	TmpGuid->Data4[3],
698	TmpGuid->Data4[4],
699	TmpGuid->Data4[5],
700	TmpGuid->Data4[6],
701	TmpGuid->Data4[7]
702	);
703	ArgumentString = ValueBuffer;
704	}
705	break;
706
707	case 't':
708	if (BaseListMarker == NULL) {
709	TmpTime = VA_ARG (VaListMarker, TIME *);
710	} else {
711	TmpTime = BASE_ARG (BaseListMarker, TIME *);
712	}
713	if (TmpTime == NULL) {
714	ArgumentString = "<null time>";
715	} else {
716	BasePrintLibSPrint (
717	ValueBuffer,
718	MAXIMUM_VALUE_CHARACTERS,
719	0,
720	"%02d/%02d/%04d %02d:%02d",
721	TmpTime->Month,
722	TmpTime->Day,
723	TmpTime->Year,
724	TmpTime->Hour,
725	TmpTime->Minute
726	);
727	ArgumentString = ValueBuffer;
728	}
729	break;
730
731	case 'r':
732	if (BaseListMarker == NULL) {
733	Status = VA_ARG (VaListMarker, RETURN_STATUS);
734	} else {
735	Status = BASE_ARG (BaseListMarker, RETURN_STATUS);
736	}
737	ArgumentString = ValueBuffer;
738	if (RETURN_ERROR (Status)) {
739	//
740	// Clear error bit
741	//
742	Index = Status & ~MAX_BIT;
743	if (Index > 0 && Index <= ERROR_STATUS_NUMBER) {
744	ArgumentString = mStatusString [Index + WARNING_STATUS_NUMBER];
745	}
746	} else {
747	Index = Status;
748	if (Index <= WARNING_STATUS_NUMBER) {
749	ArgumentString = mStatusString [Index];
750	}
751	}
752	if (ArgumentString == ValueBuffer) {
753	BasePrintLibSPrint ((CHAR8 *) ValueBuffer, MAXIMUM_VALUE_CHARACTERS, 0, "%08X", Status);
754	}
755	break;
756
757	case '\r':
758	Format += BytesPerFormatCharacter;
759	FormatCharacter = ((Format & 0xff) \| ((Format + 1) << 8)) & FormatMask;
760	if (FormatCharacter == '\n') {
761	//
762	// Translate '\r\n' to '\r\n'
763	//
764	ArgumentString = "\r\n";
765	} else {
766	//
767	// Translate '\r' to '\r'
768	//
769	ArgumentString = "\r";
770	Format -= BytesPerFormatCharacter;
771	}
772	break;
773
774	case '\n':
775	//
776	// Translate '\n' to '\r\n' and '\n\r' to '\r\n'
777	//
778	ArgumentString = "\r\n";
779	Format += BytesPerFormatCharacter;
780	FormatCharacter = ((Format & 0xff) \| ((Format + 1) << 8)) & FormatMask;
781	if (FormatCharacter != '\r') {
782	Format -= BytesPerFormatCharacter;
783	}
784	break;
785
786	case '%':
787	default:
788	//
789	// if the type is '%' or unknown, then print it to the screen
790	//
791	ArgumentString = (CHAR8 *)&FormatCharacter;
792	Flags \|= ARGUMENT_UNICODE;
793	break;
794	}
795	break;
796
797	case '\r':
798	Format += BytesPerFormatCharacter;
799	FormatCharacter = ((Format & 0xff) \| ((Format + 1) << 8)) & FormatMask;
800	if (FormatCharacter == '\n') {
801	//
802	// Translate '\r\n' to '\r\n'
803	//
804	ArgumentString = "\r\n";
805	} else {
806	//
807	// Translate '\r' to '\r'
808	//
809	ArgumentString = "\r";
810	Format -= BytesPerFormatCharacter;
811	}
812	break;
813
814	case '\n':
815	//
816	// Translate '\n' to '\r\n' and '\n\r' to '\r\n'
817	//
818	ArgumentString = "\r\n";
819	Format += BytesPerFormatCharacter;
820	FormatCharacter = ((Format & 0xff) \| ((Format + 1) << 8)) & FormatMask;
821	if (FormatCharacter != '\r') {
822	Format -= BytesPerFormatCharacter;
823	}
824	break;
825
826	default:
827	ArgumentString = (CHAR8 *)&FormatCharacter;
828	Flags \|= ARGUMENT_UNICODE;
829	break;
830	}
831
832	//
833	// Retrieve the ArgumentString attriubutes
834	//
835	if ((Flags & ARGUMENT_UNICODE) != 0) {
836	ArgumentMask = 0xffff;
837	BytesPerArgumentCharacter = 2;
838	} else {
839	ArgumentMask = 0xff;
840	BytesPerArgumentCharacter = 1;
841	}
842	if ((Flags & ARGUMENT_REVERSED) != 0) {
843	BytesPerArgumentCharacter = -BytesPerArgumentCharacter;
844	} else {
845	//
846	// Compute the number of characters in ArgumentString and store it in Count
847	// ArgumentString is either null-terminated, or it contains Precision characters
848	//
849	for (Count = 0; Count < Precision \|\| ((Flags & PRECISION) == 0); Count++) {
850	ArgumentCharacter = ((ArgumentString[Count * BytesPerArgumentCharacter] & 0xff) \| ((ArgumentString[Count * BytesPerArgumentCharacter + 1]) << 8)) & ArgumentMask;
851	if (ArgumentCharacter == 0) {
852	break;
853	}
854	}
855	}
856
857	if (Precision < Count) {
858	Precision = Count;
859	}
860
861	//
862	// Pad before the string
863	//
864	if ((Flags & (PAD_TO_WIDTH \| LEFT_JUSTIFY)) == (PAD_TO_WIDTH)) {
865	LengthToReturn += ((Width - Precision) * BytesPerOutputCharacter);
866	if ((Flags & COUNT_ONLY_NO_PRINT) == 0 && Buffer != NULL) {
867	Buffer = BasePrintLibFillBuffer (Buffer, EndBuffer, Width - Precision, ' ', BytesPerOutputCharacter);
868	}
869	}
870
871	if (ZeroPad) {
872	if (Prefix != 0) {
873	LengthToReturn += (1 * BytesPerOutputCharacter);
874	if ((Flags & COUNT_ONLY_NO_PRINT) == 0 && Buffer != NULL) {
875	Buffer = BasePrintLibFillBuffer (Buffer, EndBuffer, 1, Prefix, BytesPerOutputCharacter);
876	}
877	}
878	LengthToReturn += ((Precision - Count) * BytesPerOutputCharacter);
879	if ((Flags & COUNT_ONLY_NO_PRINT) == 0 && Buffer != NULL) {
880	Buffer = BasePrintLibFillBuffer (Buffer, EndBuffer, Precision - Count, '0', BytesPerOutputCharacter);
881	}
882	} else {
883	LengthToReturn += ((Precision - Count) * BytesPerOutputCharacter);
884	if ((Flags & COUNT_ONLY_NO_PRINT) == 0 && Buffer != NULL) {
885	Buffer = BasePrintLibFillBuffer (Buffer, EndBuffer, Precision - Count, ' ', BytesPerOutputCharacter);
886	}
887	if (Prefix != 0) {
888	LengthToReturn += (1 * BytesPerOutputCharacter);
889	if ((Flags & COUNT_ONLY_NO_PRINT) == 0 && Buffer != NULL) {
890	Buffer = BasePrintLibFillBuffer (Buffer, EndBuffer, 1, Prefix, BytesPerOutputCharacter);
891	}
892	}
893	}
894
895	//
896	// Output the Prefix character if it is present
897	//
898	Index = 0;
899	if (Prefix != 0) {
900	Index++;
901	}
902
903	//
904	// Copy the string into the output buffer performing the required type conversions
905	//
906	while (Index < Count) {
907	ArgumentCharacter = ((ArgumentString & 0xff) \| ((ArgumentString + 1) << 8)) & ArgumentMask;
908
909	LengthToReturn += (1 * BytesPerOutputCharacter);
910	if ((Flags & COUNT_ONLY_NO_PRINT) == 0 && Buffer != NULL) {
911	Buffer = BasePrintLibFillBuffer (Buffer, EndBuffer, 1, ArgumentCharacter, BytesPerOutputCharacter);
912	}
913	ArgumentString += BytesPerArgumentCharacter;
914	Index++;
915	if (Comma) {
916	Digits++;
917	if (Digits == 3) {
918	Digits = 0;
919	Index++;
920	if (Index < Count) {
921	LengthToReturn += (1 * BytesPerOutputCharacter);
922	if ((Flags & COUNT_ONLY_NO_PRINT) == 0 && Buffer != NULL) {
923	Buffer = BasePrintLibFillBuffer (Buffer, EndBuffer, 1, ',', BytesPerOutputCharacter);
924	}
925	}
926	}
927	}
928	}
929
930	//
931	// Pad after the string
932	//
933	if ((Flags & (PAD_TO_WIDTH \| LEFT_JUSTIFY)) == (PAD_TO_WIDTH \| LEFT_JUSTIFY)) {
934	LengthToReturn += ((Width - Precision) * BytesPerOutputCharacter);
935	if ((Flags & COUNT_ONLY_NO_PRINT) == 0 && Buffer != NULL) {
936	Buffer = BasePrintLibFillBuffer (Buffer, EndBuffer, Width - Precision, ' ', BytesPerOutputCharacter);
937	}
938	}
939
940	//
941	// Get the next character from the format string
942	//
943	Format += BytesPerFormatCharacter;
944
945	//
946	// Get the next character from the format string
947	//
948	FormatCharacter = ((Format & 0xff) \| ((Format + 1) << 8)) & FormatMask;
949	}
950
951	if ((Flags & COUNT_ONLY_NO_PRINT) != 0) {
952	return (LengthToReturn / BytesPerOutputCharacter);
953	}
954
955	ASSERT (Buffer != NULL);
956	//
957	// Null terminate the Unicode or ASCII string
958	//
959	BasePrintLibFillBuffer (Buffer, EndBuffer + BytesPerOutputCharacter, 1, 0, BytesPerOutputCharacter);
960	//
961	// Make sure output buffer cannot contain more than PcdMaximumUnicodeStringLength
962	// Unicode characters if PcdMaximumUnicodeStringLength is not zero.
963	//
964	ASSERT ((((Flags & OUTPUT_UNICODE) == 0)) \|\| (StrSize ((CHAR16 *) OriginalBuffer) != 0));
965	//
966	// Make sure output buffer cannot contain more than PcdMaximumAsciiStringLength
967	// ASCII characters if PcdMaximumAsciiStringLength is not zero.
968	//
969	ASSERT ((((Flags & OUTPUT_UNICODE) != 0)) \|\| (AsciiStrSize (OriginalBuffer) != 0));
970
971	return ((Buffer - OriginalBuffer) / BytesPerOutputCharacter);
972	}
973
974	/**
975	Worker function that produces a Null-terminated string in an output buffer
976	based on a Null-terminated format string and variable argument list.
977
978	VSPrint function to process format and place the results in Buffer. Since a
979	VA_LIST is used this routine allows the nesting of Vararg routines. Thus
980	this is the main print working routine
981
982	@param StartOfBuffer The character buffer to print the results of the parsing
983	of Format into.
984	@param BufferSize The maximum number of characters to put into buffer.
985	Zero means no limit.
986	@param Flags Initial flags value.
987	Can only have FORMAT_UNICODE and OUTPUT_UNICODE set
988	@param FormatString A Null-terminated format string.
989	@param ... The variable argument list.
990
991	@return The number of characters printed.
992
993	**/
994	UINTN
995	EFIAPI
996	BasePrintLibSPrint (
997	OUT CHAR8 *StartOfBuffer,
998	IN UINTN BufferSize,
999	IN UINTN Flags,
1000	IN CONST CHAR8 *FormatString,
1001	...
1002	)
1003	{
1004	VA_LIST Marker;
1005	UINTN NumberOfPrinted;
1006
1007	VA_START (Marker, FormatString);
1008	NumberOfPrinted = BasePrintLibSPrintMarker (StartOfBuffer, BufferSize, Flags, FormatString, Marker, NULL);
1009	VA_END (Marker);
1010	return NumberOfPrinted;
1011	}

注意: 瀏覽 TracBrowser 來幫助您使用儲存庫瀏覽器

source: vbox/trunk/src/VBox/Devices/EFI/Firmware/MdePkg/Library/BasePrintLib/PrintLibInternal.c@ 62180

以其他格式下載: