File: | home/coreboot/node-root/workspace/coreboot_scanbuild/3rdparty/stm/Stm/StmPkg/EdkII/MdePkg/Library/BasePrintLib/PrintLibInternal.c |
Warning: | line 798, column 148 The left operand of '<<' is a garbage value |
Press '?' to see keyboard shortcuts
Keyboard shortcuts:
1 | /** @file | |||
2 | Print Library internal worker functions. | |||
3 | ||||
4 | Copyright (c) 2006 - 2010, 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_NUMBER4 4 | |||
18 | #define ERROR_STATUS_NUMBER24 24 | |||
19 | ||||
20 | GLOBAL_REMOVE_IF_UNREFERENCED CONSTconst CHAR8 mHexStr[] = {'0','1','2','3','4','5','6','7','8','9','A','B','C','D','E','F'}; | |||
21 | ||||
22 | GLOBAL_REMOVE_IF_UNREFERENCED CONSTconst 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 | |||
52 | }; | |||
53 | ||||
54 | ||||
55 | /** | |||
56 | Internal function that places the character into the Buffer. | |||
57 | ||||
58 | Internal function that places ASCII or Unicode character into the Buffer. | |||
59 | ||||
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 | |||
62 | placed after that. | |||
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. | |||
67 | ||||
68 | @return Buffer. | |||
69 | ||||
70 | **/ | |||
71 | CHAR8 * | |||
72 | BasePrintLibFillBuffer ( | |||
73 | OUT CHAR8 *Buffer, | |||
74 | IN CHAR8 *EndBuffer, | |||
75 | IN INTN Length, | |||
76 | IN UINTN Character, | |||
77 | IN INTN Increment | |||
78 | ) | |||
79 | { | |||
80 | INTN Index; | |||
81 | ||||
82 | for (Index = 0; Index < Length && Buffer < EndBuffer; Index++) { | |||
83 | *Buffer = (CHAR8) Character; | |||
84 | if (Increment != 1) { | |||
85 | *(Buffer + 1) = (CHAR8)(Character >> 8); | |||
86 | } | |||
87 | Buffer += Increment; | |||
88 | } | |||
89 | ||||
90 | return Buffer; | |||
91 | } | |||
92 | ||||
93 | /** | |||
94 | Internal function that convert a number to a string in Buffer. | |||
95 | ||||
96 | Print worker function that converts a decimal or hexadecimal number to an ASCII string in Buffer. | |||
97 | ||||
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 | |||
101 | ||||
102 | @return A pointer to the end of buffer filled with ASCII string. | |||
103 | ||||
104 | **/ | |||
105 | CHAR8 * | |||
106 | BasePrintLibValueToString ( | |||
107 | IN OUT CHAR8 *Buffer, | |||
108 | IN INT64 Value, | |||
109 | IN UINTN Radix | |||
110 | ) | |||
111 | { | |||
112 | UINT32 Remainder; | |||
113 | ||||
114 | // | |||
115 | // Loop to convert one digit at a time in reverse order | |||
116 | // | |||
117 | *Buffer = 0; | |||
118 | do { | |||
119 | Value = (INT64)DivU64x32Remainder ((UINT64)Value, (UINT32)Radix, &Remainder); | |||
120 | *(++Buffer) = mHexStr[Remainder]; | |||
121 | } while (Value != 0); | |||
122 | ||||
123 | // | |||
124 | // Return pointer of the end of filled buffer. | |||
125 | // | |||
126 | return Buffer; | |||
127 | } | |||
128 | ||||
129 | /** | |||
130 | Internal function that converts a decimal value to a Null-terminated string. | |||
131 | ||||
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. | |||
150 | ||||
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() | |||
154 | ||||
155 | @param Buffer The pointer to the output buffer for the produced Null-terminated | |||
156 | string. | |||
157 | @param Flags The bitmask of flags that specify left justification, zero pad, | |||
158 | and commas. | |||
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 | |||
161 | the Null-terminator. | |||
162 | @param Increment The character increment in Buffer. | |||
163 | ||||
164 | @return Total number of characters required to perform the conversion. | |||
165 | ||||
166 | **/ | |||
167 | UINTN | |||
168 | BasePrintLibConvertValueToString ( | |||
169 | IN OUT CHAR8 *Buffer, | |||
170 | IN UINTN Flags, | |||
171 | IN INT64 Value, | |||
172 | IN UINTN Width, | |||
173 | IN UINTN Increment | |||
174 | ) | |||
175 | { | |||
176 | CHAR8 *OriginalBuffer; | |||
177 | CHAR8 *EndBuffer; | |||
178 | CHAR8 ValueBuffer[MAXIMUM_VALUE_CHARACTERS38]; | |||
179 | CHAR8 *ValueBufferPtr; | |||
180 | UINTN Count; | |||
181 | UINTN Digits; | |||
182 | UINTN Index; | |||
183 | UINTN Radix; | |||
184 | ||||
185 | // | |||
186 | // Make sure Buffer is not NULL and Width < MAXIMUM | |||
187 | // | |||
188 | ASSERT (Buffer != NULL)do { if (DebugAssertEnabled ()) { if (!(Buffer != ((void *) 0 ))) { DebugAssert ("/home/coreboot/node-root/workspace/coreboot_scanbuild/3rdparty/stm/Stm/StmPkg/EdkII/MdePkg/Library/BasePrintLib/PrintLibInternal.c" , 188, "Buffer != ((void *) 0)"); } } } while (((BOOLEAN)(0== 1))); | |||
189 | ASSERT (Width < MAXIMUM_VALUE_CHARACTERS)do { if (DebugAssertEnabled ()) { if (!(Width < 38)) { DebugAssert ("/home/coreboot/node-root/workspace/coreboot_scanbuild/3rdparty/stm/Stm/StmPkg/EdkII/MdePkg/Library/BasePrintLib/PrintLibInternal.c" , 189, "Width < 38"); } } } while (((BOOLEAN)(0==1))); | |||
190 | // | |||
191 | // Make sure Flags can only contain supported bits. | |||
192 | // | |||
193 | ASSERT ((Flags & ~(LEFT_JUSTIFY | COMMA_TYPE | PREFIX_ZERO | RADIX_HEX)) == 0)do { if (DebugAssertEnabled ()) { if (!((Flags & ~(0x01 | 0x08 | 0x20 | 0x80)) == 0)) { DebugAssert ("/home/coreboot/node-root/workspace/coreboot_scanbuild/3rdparty/stm/Stm/StmPkg/EdkII/MdePkg/Library/BasePrintLib/PrintLibInternal.c" , 193, "(Flags & ~(0x01 | 0x08 | 0x20 | 0x80)) == 0"); } } } while (((BOOLEAN)(0==1))); | |||
194 | ||||
195 | // | |||
196 | // If both COMMA_TYPE and RADIX_HEX are set, then ASSERT () | |||
197 | // | |||
198 | ASSERT (((Flags & COMMA_TYPE) == 0) || ((Flags & RADIX_HEX) == 0))do { if (DebugAssertEnabled ()) { if (!(((Flags & 0x08) == 0) || ((Flags & 0x80) == 0))) { DebugAssert ("/home/coreboot/node-root/workspace/coreboot_scanbuild/3rdparty/stm/Stm/StmPkg/EdkII/MdePkg/Library/BasePrintLib/PrintLibInternal.c" , 198, "((Flags & 0x08) == 0) || ((Flags & 0x80) == 0)" ); } } } while (((BOOLEAN)(0==1))); | |||
199 | ||||
200 | OriginalBuffer = Buffer; | |||
201 | ||||
202 | // | |||
203 | // Width is 0 or COMMA_TYPE is set, PREFIX_ZERO is ignored. | |||
204 | // | |||
205 | if (Width == 0 || (Flags & COMMA_TYPE0x08) != 0) { | |||
206 | Flags &= (~PREFIX_ZERO0x20); | |||
207 | } | |||
208 | // | |||
209 | // If Width is 0 then a width of MAXIMUM_VALUE_CHARACTERS is assumed. | |||
210 | // | |||
211 | if (Width == 0) { | |||
212 | Width = MAXIMUM_VALUE_CHARACTERS38 - 1; | |||
213 | } | |||
214 | // | |||
215 | // Set the tag for the end of the input Buffer. | |||
216 | // | |||
217 | EndBuffer = Buffer + Width * Increment; | |||
218 | ||||
219 | // | |||
220 | // Convert decimal negative | |||
221 | // | |||
222 | if ((Value < 0) && ((Flags & RADIX_HEX0x80) == 0)) { | |||
223 | Value = -Value; | |||
224 | Buffer = BasePrintLibFillBuffer (Buffer, EndBuffer, 1, '-', Increment); | |||
225 | Width--; | |||
226 | } | |||
227 | ||||
228 | // | |||
229 | // Count the length of the value string. | |||
230 | // | |||
231 | Radix = ((Flags & RADIX_HEX0x80) == 0)? 10 : 16; | |||
232 | ValueBufferPtr = BasePrintLibValueToString (ValueBuffer, Value, Radix); | |||
233 | Count = ValueBufferPtr - ValueBuffer; | |||
234 | ||||
235 | // | |||
236 | // Append Zero | |||
237 | // | |||
238 | if ((Flags & PREFIX_ZERO0x20) != 0) { | |||
239 | Buffer = BasePrintLibFillBuffer (Buffer, EndBuffer, Width - Count, '0', Increment); | |||
240 | } | |||
241 | ||||
242 | // | |||
243 | // Print Comma type for every 3 characters | |||
244 | // | |||
245 | Digits = Count % 3; | |||
246 | if (Digits != 0) { | |||
247 | Digits = 3 - Digits; | |||
248 | } | |||
249 | for (Index = 0; Index < Count; Index++) { | |||
250 | Buffer = BasePrintLibFillBuffer (Buffer, EndBuffer, 1, *ValueBufferPtr--, Increment); | |||
251 | if ((Flags & COMMA_TYPE0x08) != 0) { | |||
252 | Digits++; | |||
253 | if (Digits == 3) { | |||
254 | Digits = 0; | |||
255 | if ((Index + 1) < Count) { | |||
256 | Buffer = BasePrintLibFillBuffer (Buffer, EndBuffer, 1, ',', Increment); | |||
257 | } | |||
258 | } | |||
259 | } | |||
260 | } | |||
261 | ||||
262 | // | |||
263 | // Print Null-terminator | |||
264 | // | |||
265 | BasePrintLibFillBuffer (Buffer, EndBuffer + Increment, 1, 0, Increment); | |||
266 | ||||
267 | return ((Buffer - OriginalBuffer) / Increment); | |||
268 | } | |||
269 | ||||
270 | /** | |||
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. | |||
273 | ||||
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. | |||
277 | ||||
278 | @param Buffer The character buffer to print the results of the parsing | |||
279 | of Format into. | |||
280 | @param BufferSize The maximum number of characters to put into buffer. | |||
281 | @param Flags Initial flags value. | |||
282 | Can only have FORMAT_UNICODE and OUTPUT_UNICODE set. | |||
283 | @param Format A Null-terminated format string. | |||
284 | @param VaListMarker VA_LIST style variable argument list consumed by processing Format. | |||
285 | @param BaseListMarker BASE_LIST style variable argument list consumed by processing Format. | |||
286 | ||||
287 | @return The number of characters printed not including the Null-terminator. | |||
288 | ||||
289 | **/ | |||
290 | UINTN | |||
291 | BasePrintLibSPrintMarker ( | |||
292 | OUT CHAR8 *Buffer, | |||
293 | IN UINTN BufferSize, | |||
294 | IN UINTN Flags, | |||
295 | IN CONSTconst CHAR8 *Format, | |||
296 | IN VA_LIST VaListMarker, OPTIONAL | |||
297 | IN BASE_LIST BaseListMarker OPTIONAL | |||
298 | ) | |||
299 | { | |||
300 | CHAR8 *OriginalBuffer; | |||
301 | CHAR8 *EndBuffer; | |||
302 | CHAR8 ValueBuffer[MAXIMUM_VALUE_CHARACTERS38]; | |||
303 | UINTN BytesPerOutputCharacter; | |||
304 | UINTN BytesPerFormatCharacter; | |||
305 | UINTN FormatMask; | |||
306 | UINTN FormatCharacter; | |||
307 | UINTN Width; | |||
308 | UINTN Precision; | |||
309 | INT64 Value; | |||
310 | CONSTconst CHAR8 *ArgumentString; | |||
311 | UINTN Character; | |||
312 | GUID *TmpGuid; | |||
313 | TIME *TmpTime; | |||
314 | UINTN Count; | |||
315 | UINTN ArgumentMask; | |||
316 | INTN BytesPerArgumentCharacter; | |||
317 | UINTN ArgumentCharacter; | |||
318 | BOOLEAN Done; | |||
319 | UINTN Index; | |||
320 | CHAR8 Prefix; | |||
321 | BOOLEAN ZeroPad; | |||
322 | BOOLEAN Comma; | |||
323 | UINTN Digits; | |||
324 | UINTN Radix; | |||
325 | RETURN_STATUS Status; | |||
326 | ||||
327 | if (BufferSize == 0) { | |||
| ||||
328 | return 0; | |||
329 | } | |||
330 | ASSERT (Buffer != NULL)do { if (DebugAssertEnabled ()) { if (!(Buffer != ((void *) 0 ))) { DebugAssert ("/home/coreboot/node-root/workspace/coreboot_scanbuild/3rdparty/stm/Stm/StmPkg/EdkII/MdePkg/Library/BasePrintLib/PrintLibInternal.c" , 330, "Buffer != ((void *) 0)"); } } } while (((BOOLEAN)(0== 1))); | |||
331 | ||||
332 | if ((Flags & OUTPUT_UNICODE0x40) != 0) { | |||
333 | BytesPerOutputCharacter = 2; | |||
334 | } else { | |||
335 | BytesPerOutputCharacter = 1; | |||
336 | } | |||
337 | ||||
338 | // | |||
339 | // Reserve space for the Null terminator. | |||
340 | // | |||
341 | BufferSize--; | |||
342 | OriginalBuffer = Buffer; | |||
343 | ||||
344 | // | |||
345 | // Set the tag for the end of the input Buffer. | |||
346 | // | |||
347 | EndBuffer = Buffer + BufferSize * BytesPerOutputCharacter; | |||
348 | ||||
349 | if ((Flags & FORMAT_UNICODE0x100) != 0) { | |||
350 | // | |||
351 | // Make sure format string cannot contain more than PcdMaximumUnicodeStringLength | |||
352 | // Unicode characters if PcdMaximumUnicodeStringLength is not zero. | |||
353 | // | |||
354 | ASSERT (StrSize ((CHAR16 *) Format) != 0)do { if (DebugAssertEnabled ()) { if (!(StrSize ((CHAR16 *) Format ) != 0)) { DebugAssert ("/home/coreboot/node-root/workspace/coreboot_scanbuild/3rdparty/stm/Stm/StmPkg/EdkII/MdePkg/Library/BasePrintLib/PrintLibInternal.c" , 354, "StrSize ((CHAR16 *) Format) != 0"); } } } while (((BOOLEAN )(0==1))); | |||
355 | BytesPerFormatCharacter = 2; | |||
356 | FormatMask = 0xffff; | |||
357 | } else { | |||
358 | // | |||
359 | // Make sure format string cannot contain more than PcdMaximumAsciiStringLength | |||
360 | // Ascii characters if PcdMaximumAsciiStringLength is not zero. | |||
361 | // | |||
362 | ASSERT (AsciiStrSize (Format) != 0)do { if (DebugAssertEnabled ()) { if (!(AsciiStrSize (Format) != 0)) { DebugAssert ("/home/coreboot/node-root/workspace/coreboot_scanbuild/3rdparty/stm/Stm/StmPkg/EdkII/MdePkg/Library/BasePrintLib/PrintLibInternal.c" , 362, "AsciiStrSize (Format) != 0"); } } } while (((BOOLEAN) (0==1))); | |||
363 | BytesPerFormatCharacter = 1; | |||
364 | FormatMask = 0xff; | |||
365 | } | |||
366 | ||||
367 | // | |||
368 | // Get the first character from the format string | |||
369 | // | |||
370 | FormatCharacter = ((*Format & 0xff) | (*(Format + 1) << 8)) & FormatMask; | |||
371 | ||||
372 | // | |||
373 | // Loop until the end of the format string is reached or the output buffer is full | |||
374 | // | |||
375 | while (FormatCharacter != 0 && Buffer < EndBuffer) { | |||
376 | // | |||
377 | // Clear all the flag bits except those that may have been passed in | |||
378 | // | |||
379 | Flags &= (OUTPUT_UNICODE0x40 | FORMAT_UNICODE0x100); | |||
380 | ||||
381 | // | |||
382 | // Set the default width to zero, and the default precision to 1 | |||
383 | // | |||
384 | Width = 0; | |||
385 | Precision = 1; | |||
386 | Prefix = 0; | |||
387 | Comma = FALSE((BOOLEAN)(0==1)); | |||
388 | ZeroPad = FALSE((BOOLEAN)(0==1)); | |||
389 | Count = 0; | |||
390 | Digits = 0; | |||
391 | ||||
392 | switch (FormatCharacter) { | |||
393 | case '%': | |||
394 | // | |||
395 | // Parse Flags and Width | |||
396 | // | |||
397 | for (Done = FALSE((BOOLEAN)(0==1)); !Done; ) { | |||
398 | Format += BytesPerFormatCharacter; | |||
399 | FormatCharacter = ((*Format & 0xff) | (*(Format + 1) << 8)) & FormatMask; | |||
400 | switch (FormatCharacter) { | |||
401 | case '.': | |||
402 | Flags |= PRECISION0x800; | |||
403 | break; | |||
404 | case '-': | |||
405 | Flags |= LEFT_JUSTIFY0x01; | |||
406 | break; | |||
407 | case '+': | |||
408 | Flags |= PREFIX_SIGN0x02; | |||
409 | break; | |||
410 | case ' ': | |||
411 | Flags |= PREFIX_BLANK0x04; | |||
412 | break; | |||
413 | case ',': | |||
414 | Flags |= COMMA_TYPE0x08; | |||
415 | break; | |||
416 | case 'L': | |||
417 | case 'l': | |||
418 | Flags |= LONG_TYPE0x10; | |||
419 | break; | |||
420 | case '*': | |||
421 | if ((Flags & PRECISION0x800) == 0) { | |||
422 | Flags |= PAD_TO_WIDTH0x200; | |||
423 | if (BaseListMarker == NULL((void *) 0)) { | |||
424 | Width = VA_ARG (VaListMarker, UINTN)((sizeof (UINTN) < sizeof (UINTN)) ? (UINTN)(__builtin_va_arg (VaListMarker, UINTN)) : (UINTN)(__builtin_va_arg (VaListMarker , UINTN))); | |||
425 | } else { | |||
426 | Width = BASE_ARG (BaseListMarker, UINTN)(*(UINTN *) ((BaseListMarker += ((sizeof (UINTN) + sizeof (UINTN ) - 1) / sizeof (UINTN))) - ((sizeof (UINTN) + sizeof (UINTN) - 1) / sizeof (UINTN)))); | |||
427 | } | |||
428 | } else { | |||
429 | if (BaseListMarker == NULL((void *) 0)) { | |||
430 | Precision = VA_ARG (VaListMarker, UINTN)((sizeof (UINTN) < sizeof (UINTN)) ? (UINTN)(__builtin_va_arg (VaListMarker, UINTN)) : (UINTN)(__builtin_va_arg (VaListMarker , UINTN))); | |||
431 | } else { | |||
432 | Precision = BASE_ARG (BaseListMarker, UINTN)(*(UINTN *) ((BaseListMarker += ((sizeof (UINTN) + sizeof (UINTN ) - 1) / sizeof (UINTN))) - ((sizeof (UINTN) + sizeof (UINTN) - 1) / sizeof (UINTN)))); | |||
433 | } | |||
434 | } | |||
435 | break; | |||
436 | case '0': | |||
437 | if ((Flags & PRECISION0x800) == 0) { | |||
438 | Flags |= PREFIX_ZERO0x20; | |||
439 | } | |||
440 | case '1': | |||
441 | case '2': | |||
442 | case '3': | |||
443 | case '4': | |||
444 | case '5': | |||
445 | case '6': | |||
446 | case '7': | |||
447 | case '8': | |||
448 | case '9': | |||
449 | for (Count = 0; ((FormatCharacter >= '0') && (FormatCharacter <= '9')); ){ | |||
450 | Count = (Count * 10) + FormatCharacter - '0'; | |||
451 | Format += BytesPerFormatCharacter; | |||
452 | FormatCharacter = ((*Format & 0xff) | (*(Format + 1) << 8)) & FormatMask; | |||
453 | } | |||
454 | Format -= BytesPerFormatCharacter; | |||
455 | if ((Flags & PRECISION0x800) == 0) { | |||
456 | Flags |= PAD_TO_WIDTH0x200; | |||
457 | Width = Count; | |||
458 | } else { | |||
459 | Precision = Count; | |||
460 | } | |||
461 | break; | |||
462 | ||||
463 | case '\0': | |||
464 | // | |||
465 | // Make no output if Format string terminates unexpectedly when | |||
466 | // looking up for flag, width, precision and type. | |||
467 | // | |||
468 | Format -= BytesPerFormatCharacter; | |||
469 | Precision = 0; | |||
470 | // | |||
471 | // break skipped on purpose. | |||
472 | // | |||
473 | default: | |||
474 | Done = TRUE((BOOLEAN)(1==1)); | |||
475 | break; | |||
476 | } | |||
477 | } | |||
478 | ||||
479 | // | |||
480 | // Handle each argument type | |||
481 | // | |||
482 | switch (FormatCharacter) { | |||
483 | case 'p': | |||
484 | // | |||
485 | // Flag space, +, 0, L & l are invalid for type p. | |||
486 | // | |||
487 | Flags &= ~(PREFIX_BLANK0x04 | PREFIX_SIGN0x02 | PREFIX_ZERO0x20 | LONG_TYPE0x10); | |||
488 | if (sizeof (VOIDvoid *) > 4) { | |||
489 | Flags |= LONG_TYPE0x10; | |||
490 | } | |||
491 | case 'X': | |||
492 | Flags |= PREFIX_ZERO0x20; | |||
493 | // | |||
494 | // break skipped on purpose | |||
495 | // | |||
496 | case 'x': | |||
497 | Flags |= RADIX_HEX0x80; | |||
498 | // | |||
499 | // break skipped on purpose | |||
500 | // | |||
501 | case 'd': | |||
502 | if ((Flags & LONG_TYPE0x10) == 0) { | |||
503 | // | |||
504 | // 'd','x', and 'X' that are not preceded by 'l' or 'L' are assumed to be type "int". | |||
505 | // This assumption is made so the format string definition is compatible with the ANSI C | |||
506 | // Specification for formatted strings. It is recommended that the Base Types be used | |||
507 | // everywhere, but in this one case, compliance with ANSI C is more important, and | |||
508 | // provides an implementation that is compatible with that largest possible set of CPU | |||
509 | // architectures. This is why the type "int" is used in this one case. | |||
510 | // | |||
511 | if (BaseListMarker == NULL((void *) 0)) { | |||
512 | Value = VA_ARG (VaListMarker, int)((sizeof (int) < sizeof (UINTN)) ? (int)(__builtin_va_arg ( VaListMarker, UINTN)) : (int)(__builtin_va_arg (VaListMarker, int))); | |||
513 | } else { | |||
514 | Value = BASE_ARG (BaseListMarker, int)(*(int *) ((BaseListMarker += ((sizeof (int) + sizeof (UINTN) - 1) / sizeof (UINTN))) - ((sizeof (int) + sizeof (UINTN) - 1 ) / sizeof (UINTN)))); | |||
515 | } | |||
516 | } else { | |||
517 | if (BaseListMarker == NULL((void *) 0)) { | |||
518 | Value = VA_ARG (VaListMarker, INT64)((sizeof (INT64) < sizeof (UINTN)) ? (INT64)(__builtin_va_arg (VaListMarker, UINTN)) : (INT64)(__builtin_va_arg (VaListMarker , INT64))); | |||
519 | } else { | |||
520 | Value = BASE_ARG (BaseListMarker, INT64)(*(INT64 *) ((BaseListMarker += ((sizeof (INT64) + sizeof (UINTN ) - 1) / sizeof (UINTN))) - ((sizeof (INT64) + sizeof (UINTN) - 1) / sizeof (UINTN)))); | |||
521 | } | |||
522 | } | |||
523 | if ((Flags & PREFIX_BLANK0x04) != 0) { | |||
524 | Prefix = ' '; | |||
525 | } | |||
526 | if ((Flags & PREFIX_SIGN0x02) != 0) { | |||
527 | Prefix = '+'; | |||
528 | } | |||
529 | if ((Flags & COMMA_TYPE0x08) != 0) { | |||
530 | Comma = TRUE((BOOLEAN)(1==1)); | |||
531 | } | |||
532 | if ((Flags & RADIX_HEX0x80) == 0) { | |||
533 | Radix = 10; | |||
534 | if (Comma) { | |||
535 | Flags &= (~PREFIX_ZERO0x20); | |||
536 | Precision = 1; | |||
537 | } | |||
538 | if (Value < 0) { | |||
539 | Flags |= PREFIX_SIGN0x02; | |||
540 | Prefix = '-'; | |||
541 | Value = -Value; | |||
542 | } | |||
543 | } else { | |||
544 | Radix = 16; | |||
545 | Comma = FALSE((BOOLEAN)(0==1)); | |||
546 | if ((Flags & LONG_TYPE0x10) == 0 && Value < 0) { | |||
547 | // | |||
548 | // 'd','x', and 'X' that are not preceded by 'l' or 'L' are assumed to be type "int". | |||
549 | // This assumption is made so the format string definition is compatible with the ANSI C | |||
550 | // Specification for formatted strings. It is recommended that the Base Types be used | |||
551 | // everywhere, but in this one case, compliance with ANSI C is more important, and | |||
552 | // provides an implementation that is compatible with that largest possible set of CPU | |||
553 | // architectures. This is why the type "unsigned int" is used in this one case. | |||
554 | // | |||
555 | Value = (unsigned int)Value; | |||
556 | } | |||
557 | } | |||
558 | // | |||
559 | // Convert Value to a reversed string | |||
560 | // | |||
561 | Count = BasePrintLibValueToString (ValueBuffer, Value, Radix) - ValueBuffer; | |||
562 | if (Value == 0 && Precision == 0) { | |||
563 | Count = 0; | |||
564 | } | |||
565 | ArgumentString = (CHAR8 *)ValueBuffer + Count; | |||
566 | ||||
567 | Digits = Count % 3; | |||
568 | if (Digits
| |||
569 | Digits = 3 - Digits; | |||
570 | } | |||
571 | if (Comma
| |||
572 | Count += ((Count - 1) / 3); | |||
573 | } | |||
574 | if (Prefix
| |||
575 | Count++; | |||
576 | Precision++; | |||
577 | } | |||
578 | Flags |= ARGUMENT_REVERSED0x1000; | |||
579 | ZeroPad = TRUE((BOOLEAN)(1==1)); | |||
580 | if ((Flags & PREFIX_ZERO0x20) != 0) { | |||
581 | if ((Flags & LEFT_JUSTIFY0x01) == 0) { | |||
582 | if ((Flags & PAD_TO_WIDTH0x200) != 0) { | |||
583 | if ((Flags & PRECISION0x800) == 0) { | |||
584 | Precision = Width; | |||
585 | } | |||
586 | } | |||
587 | } | |||
588 | } | |||
589 | break; | |||
590 | ||||
591 | case 's': | |||
592 | case 'S': | |||
593 | Flags |= ARGUMENT_UNICODE0x400; | |||
594 | // | |||
595 | // break skipped on purpose | |||
596 | // | |||
597 | case 'a': | |||
598 | if (BaseListMarker == NULL((void *) 0)) { | |||
599 | ArgumentString = VA_ARG (VaListMarker, CHAR8 *)((sizeof (CHAR8 *) < sizeof (UINTN)) ? (CHAR8 *)(__builtin_va_arg (VaListMarker, UINTN)) : (CHAR8 *)(__builtin_va_arg (VaListMarker , CHAR8 *))); | |||
600 | } else { | |||
601 | ArgumentString = BASE_ARG (BaseListMarker, CHAR8 *)(*(CHAR8 * *) ((BaseListMarker += ((sizeof (CHAR8 *) + sizeof (UINTN) - 1) / sizeof (UINTN))) - ((sizeof (CHAR8 *) + sizeof (UINTN) - 1) / sizeof (UINTN)))); | |||
602 | } | |||
603 | if (ArgumentString == NULL((void *) 0)) { | |||
604 | Flags &= (~ARGUMENT_UNICODE0x400); | |||
605 | ArgumentString = "<null string>"; | |||
606 | } | |||
607 | // | |||
608 | // Set the default precision for string to be zero if not specified. | |||
609 | // | |||
610 | if ((Flags & PRECISION0x800) == 0) { | |||
611 | Precision = 0; | |||
612 | } | |||
613 | break; | |||
614 | ||||
615 | case 'c': | |||
616 | if (BaseListMarker == NULL((void *) 0)) { | |||
617 | Character = VA_ARG (VaListMarker, UINTN)((sizeof (UINTN) < sizeof (UINTN)) ? (UINTN)(__builtin_va_arg (VaListMarker, UINTN)) : (UINTN)(__builtin_va_arg (VaListMarker , UINTN))) & 0xffff; | |||
618 | } else { | |||
619 | Character = BASE_ARG (BaseListMarker, UINTN)(*(UINTN *) ((BaseListMarker += ((sizeof (UINTN) + sizeof (UINTN ) - 1) / sizeof (UINTN))) - ((sizeof (UINTN) + sizeof (UINTN) - 1) / sizeof (UINTN)))) & 0xffff; | |||
620 | } | |||
621 | ArgumentString = (CHAR8 *)&Character; | |||
622 | Flags |= ARGUMENT_UNICODE0x400; | |||
623 | break; | |||
624 | ||||
625 | case 'g': | |||
626 | if (BaseListMarker == NULL((void *) 0)) { | |||
627 | TmpGuid = VA_ARG (VaListMarker, GUID *)((sizeof (GUID *) < sizeof (UINTN)) ? (GUID *)(__builtin_va_arg (VaListMarker, UINTN)) : (GUID *)(__builtin_va_arg (VaListMarker , GUID *))); | |||
628 | } else { | |||
629 | TmpGuid = BASE_ARG (BaseListMarker, GUID *)(*(GUID * *) ((BaseListMarker += ((sizeof (GUID *) + sizeof ( UINTN) - 1) / sizeof (UINTN))) - ((sizeof (GUID *) + sizeof ( UINTN) - 1) / sizeof (UINTN)))); | |||
630 | } | |||
631 | if (TmpGuid == NULL((void *) 0)) { | |||
632 | ArgumentString = "<null guid>"; | |||
633 | } else { | |||
634 | BasePrintLibSPrint ( | |||
635 | ValueBuffer, | |||
636 | MAXIMUM_VALUE_CHARACTERS38, | |||
637 | 0, | |||
638 | "%08x-%04x-%04x-%02x%02x-%02x%02x%02x%02x%02x%02x", | |||
639 | TmpGuid->Data1, | |||
640 | TmpGuid->Data2, | |||
641 | TmpGuid->Data3, | |||
642 | TmpGuid->Data4[0], | |||
643 | TmpGuid->Data4[1], | |||
644 | TmpGuid->Data4[2], | |||
645 | TmpGuid->Data4[3], | |||
646 | TmpGuid->Data4[4], | |||
647 | TmpGuid->Data4[5], | |||
648 | TmpGuid->Data4[6], | |||
649 | TmpGuid->Data4[7] | |||
650 | ); | |||
651 | ArgumentString = ValueBuffer; | |||
652 | } | |||
653 | break; | |||
654 | ||||
655 | case 't': | |||
656 | if (BaseListMarker == NULL((void *) 0)) { | |||
657 | TmpTime = VA_ARG (VaListMarker, TIME *)((sizeof (TIME *) < sizeof (UINTN)) ? (TIME *)(__builtin_va_arg (VaListMarker, UINTN)) : (TIME *)(__builtin_va_arg (VaListMarker , TIME *))); | |||
658 | } else { | |||
659 | TmpTime = BASE_ARG (BaseListMarker, TIME *)(*(TIME * *) ((BaseListMarker += ((sizeof (TIME *) + sizeof ( UINTN) - 1) / sizeof (UINTN))) - ((sizeof (TIME *) + sizeof ( UINTN) - 1) / sizeof (UINTN)))); | |||
660 | } | |||
661 | if (TmpTime == NULL((void *) 0)) { | |||
662 | ArgumentString = "<null time>"; | |||
663 | } else { | |||
664 | BasePrintLibSPrint ( | |||
665 | ValueBuffer, | |||
666 | MAXIMUM_VALUE_CHARACTERS38, | |||
667 | 0, | |||
668 | "%02d/%02d/%04d %02d:%02d", | |||
669 | TmpTime->Month, | |||
670 | TmpTime->Day, | |||
671 | TmpTime->Year, | |||
672 | TmpTime->Hour, | |||
673 | TmpTime->Minute | |||
674 | ); | |||
675 | ArgumentString = ValueBuffer; | |||
676 | } | |||
677 | break; | |||
678 | ||||
679 | case 'r': | |||
680 | if (BaseListMarker == NULL((void *) 0)) { | |||
681 | Status = VA_ARG (VaListMarker, RETURN_STATUS)((sizeof (RETURN_STATUS) < sizeof (UINTN)) ? (RETURN_STATUS )(__builtin_va_arg (VaListMarker, UINTN)) : (RETURN_STATUS)(__builtin_va_arg (VaListMarker, RETURN_STATUS))); | |||
682 | } else { | |||
683 | Status = BASE_ARG (BaseListMarker, RETURN_STATUS)(*(RETURN_STATUS *) ((BaseListMarker += ((sizeof (RETURN_STATUS ) + sizeof (UINTN) - 1) / sizeof (UINTN))) - ((sizeof (RETURN_STATUS ) + sizeof (UINTN) - 1) / sizeof (UINTN)))); | |||
684 | } | |||
685 | ArgumentString = ValueBuffer; | |||
686 | if (RETURN_ERROR (Status)(((INTN)(RETURN_STATUS)(Status)) < 0)) { | |||
687 | // | |||
688 | // Clear error bit | |||
689 | // | |||
690 | Index = Status & ~MAX_BIT0x8000000000000000ULL; | |||
691 | if (Index > 0 && Index <= ERROR_STATUS_NUMBER24) { | |||
692 | ArgumentString = mStatusString [Index + WARNING_STATUS_NUMBER4]; | |||
693 | } | |||
694 | } else { | |||
695 | Index = Status; | |||
696 | if (Index <= WARNING_STATUS_NUMBER4) { | |||
697 | ArgumentString = mStatusString [Index]; | |||
698 | } | |||
699 | } | |||
700 | if (ArgumentString == ValueBuffer) { | |||
701 | BasePrintLibSPrint ((CHAR8 *) ValueBuffer, MAXIMUM_VALUE_CHARACTERS38, 0, "%08X", Status); | |||
702 | } | |||
703 | break; | |||
704 | ||||
705 | case '\r': | |||
706 | Format += BytesPerFormatCharacter; | |||
707 | FormatCharacter = ((*Format & 0xff) | (*(Format + 1) << 8)) & FormatMask; | |||
708 | if (FormatCharacter == '\n') { | |||
709 | // | |||
710 | // Translate '\r\n' to '\r\n' | |||
711 | // | |||
712 | ArgumentString = "\r\n"; | |||
713 | } else { | |||
714 | // | |||
715 | // Translate '\r' to '\r' | |||
716 | // | |||
717 | ArgumentString = "\r"; | |||
718 | Format -= BytesPerFormatCharacter; | |||
719 | } | |||
720 | break; | |||
721 | ||||
722 | case '\n': | |||
723 | // | |||
724 | // Translate '\n' to '\r\n' and '\n\r' to '\r\n' | |||
725 | // | |||
726 | ArgumentString = "\r\n"; | |||
727 | Format += BytesPerFormatCharacter; | |||
728 | FormatCharacter = ((*Format & 0xff) | (*(Format + 1) << 8)) & FormatMask; | |||
729 | if (FormatCharacter != '\r') { | |||
730 | Format -= BytesPerFormatCharacter; | |||
731 | } | |||
732 | break; | |||
733 | ||||
734 | case '%': | |||
735 | default: | |||
736 | // | |||
737 | // if the type is '%' or unknown, then print it to the screen | |||
738 | // | |||
739 | ArgumentString = (CHAR8 *)&FormatCharacter; | |||
740 | Flags |= ARGUMENT_UNICODE0x400; | |||
741 | break; | |||
742 | } | |||
743 | break; | |||
744 | ||||
745 | case '\r': | |||
746 | Format += BytesPerFormatCharacter; | |||
747 | FormatCharacter = ((*Format & 0xff) | (*(Format + 1) << 8)) & FormatMask; | |||
748 | if (FormatCharacter == '\n') { | |||
749 | // | |||
750 | // Translate '\r\n' to '\r\n' | |||
751 | // | |||
752 | ArgumentString = "\r\n"; | |||
753 | } else { | |||
754 | // | |||
755 | // Translate '\r' to '\r' | |||
756 | // | |||
757 | ArgumentString = "\r"; | |||
758 | Format -= BytesPerFormatCharacter; | |||
759 | } | |||
760 | break; | |||
761 | ||||
762 | case '\n': | |||
763 | // | |||
764 | // Translate '\n' to '\r\n' and '\n\r' to '\r\n' | |||
765 | // | |||
766 | ArgumentString = "\r\n"; | |||
767 | Format += BytesPerFormatCharacter; | |||
768 | FormatCharacter = ((*Format & 0xff) | (*(Format + 1) << 8)) & FormatMask; | |||
769 | if (FormatCharacter != '\r') { | |||
770 | Format -= BytesPerFormatCharacter; | |||
771 | } | |||
772 | break; | |||
773 | ||||
774 | default: | |||
775 | ArgumentString = (CHAR8 *)&FormatCharacter; | |||
776 | Flags |= ARGUMENT_UNICODE0x400; | |||
777 | break; | |||
778 | } | |||
779 | ||||
780 | // | |||
781 | // Retrieve the ArgumentString attriubutes | |||
782 | // | |||
783 | if ((Flags & ARGUMENT_UNICODE0x400) != 0) { | |||
784 | ArgumentMask = 0xffff; | |||
785 | BytesPerArgumentCharacter = 2; | |||
786 | } else { | |||
787 | ArgumentMask = 0xff; | |||
788 | BytesPerArgumentCharacter = 1; | |||
789 | } | |||
790 | if ((Flags & ARGUMENT_REVERSED0x1000) != 0) { | |||
791 | BytesPerArgumentCharacter = -BytesPerArgumentCharacter; | |||
792 | } else { | |||
793 | // | |||
794 | // Compute the number of characters in ArgumentString and store it in Count | |||
795 | // ArgumentString is either null-terminated, or it contains Precision characters | |||
796 | // | |||
797 | for (Count = 0; Count
| |||
798 | ArgumentCharacter = ((ArgumentString[Count * BytesPerArgumentCharacter] & 0xff) | ((ArgumentString[Count * BytesPerArgumentCharacter + 1]) << 8)) & ArgumentMask; | |||
| ||||
799 | if (ArgumentCharacter == 0) { | |||
800 | break; | |||
801 | } | |||
802 | } | |||
803 | } | |||
804 | ||||
805 | if (Precision < Count) { | |||
806 | Precision = Count; | |||
807 | } | |||
808 | ||||
809 | // | |||
810 | // Pad before the string | |||
811 | // | |||
812 | if ((Flags & (PAD_TO_WIDTH0x200 | LEFT_JUSTIFY0x01)) == (PAD_TO_WIDTH0x200)) { | |||
813 | Buffer = BasePrintLibFillBuffer (Buffer, EndBuffer, Width - Precision, ' ', BytesPerOutputCharacter); | |||
814 | } | |||
815 | ||||
816 | if (ZeroPad) { | |||
817 | if (Prefix != 0) { | |||
818 | Buffer = BasePrintLibFillBuffer (Buffer, EndBuffer, 1, Prefix, BytesPerOutputCharacter); | |||
819 | } | |||
820 | Buffer = BasePrintLibFillBuffer (Buffer, EndBuffer, Precision - Count, '0', BytesPerOutputCharacter); | |||
821 | } else { | |||
822 | Buffer = BasePrintLibFillBuffer (Buffer, EndBuffer, Precision - Count, ' ', BytesPerOutputCharacter); | |||
823 | if (Prefix != 0) { | |||
824 | Buffer = BasePrintLibFillBuffer (Buffer, EndBuffer, 1, Prefix, BytesPerOutputCharacter); | |||
825 | } | |||
826 | } | |||
827 | ||||
828 | // | |||
829 | // Output the Prefix character if it is present | |||
830 | // | |||
831 | Index = 0; | |||
832 | if (Prefix != 0) { | |||
833 | Index++; | |||
834 | } | |||
835 | ||||
836 | // | |||
837 | // Copy the string into the output buffer performing the required type conversions | |||
838 | // | |||
839 | while (Index < Count) { | |||
840 | ArgumentCharacter = ((*ArgumentString & 0xff) | (*(ArgumentString + 1) << 8)) & ArgumentMask; | |||
841 | ||||
842 | Buffer = BasePrintLibFillBuffer (Buffer, EndBuffer, 1, ArgumentCharacter, BytesPerOutputCharacter); | |||
843 | ArgumentString += BytesPerArgumentCharacter; | |||
844 | Index++; | |||
845 | if (Comma) { | |||
846 | Digits++; | |||
847 | if (Digits == 3) { | |||
848 | Digits = 0; | |||
849 | Index++; | |||
850 | if (Index < Count) { | |||
851 | Buffer = BasePrintLibFillBuffer (Buffer, EndBuffer, 1, ',', BytesPerOutputCharacter); | |||
852 | } | |||
853 | } | |||
854 | } | |||
855 | } | |||
856 | ||||
857 | // | |||
858 | // Pad after the string | |||
859 | // | |||
860 | if ((Flags & (PAD_TO_WIDTH0x200 | LEFT_JUSTIFY0x01)) == (PAD_TO_WIDTH0x200 | LEFT_JUSTIFY0x01)) { | |||
861 | Buffer = BasePrintLibFillBuffer (Buffer, EndBuffer, Width - Precision, ' ', BytesPerOutputCharacter); | |||
862 | } | |||
863 | ||||
864 | // | |||
865 | // Get the next character from the format string | |||
866 | // | |||
867 | Format += BytesPerFormatCharacter; | |||
868 | ||||
869 | // | |||
870 | // Get the next character from the format string | |||
871 | // | |||
872 | FormatCharacter = ((*Format & 0xff) | (*(Format + 1) << 8)) & FormatMask; | |||
873 | } | |||
874 | ||||
875 | // | |||
876 | // Null terminate the Unicode or ASCII string | |||
877 | // | |||
878 | BasePrintLibFillBuffer (Buffer, EndBuffer + BytesPerOutputCharacter, 1, 0, BytesPerOutputCharacter); | |||
879 | // | |||
880 | // Make sure output buffer cannot contain more than PcdMaximumUnicodeStringLength | |||
881 | // Unicode characters if PcdMaximumUnicodeStringLength is not zero. | |||
882 | // | |||
883 | ASSERT ((((Flags & OUTPUT_UNICODE) == 0)) || (StrSize ((CHAR16 *) OriginalBuffer) != 0))do { if (DebugAssertEnabled ()) { if (!((((Flags & 0x40) == 0)) || (StrSize ((CHAR16 *) OriginalBuffer) != 0))) { DebugAssert ("/home/coreboot/node-root/workspace/coreboot_scanbuild/3rdparty/stm/Stm/StmPkg/EdkII/MdePkg/Library/BasePrintLib/PrintLibInternal.c" , 883, "(((Flags & 0x40) == 0)) || (StrSize ((CHAR16 *) OriginalBuffer) != 0)" ); } } } while (((BOOLEAN)(0==1))); | |||
884 | // | |||
885 | // Make sure output buffer cannot contain more than PcdMaximumAsciiStringLength | |||
886 | // ASCII characters if PcdMaximumAsciiStringLength is not zero. | |||
887 | // | |||
888 | ASSERT ((((Flags & OUTPUT_UNICODE) != 0)) || (AsciiStrSize (OriginalBuffer) != 0))do { if (DebugAssertEnabled ()) { if (!((((Flags & 0x40) != 0)) || (AsciiStrSize (OriginalBuffer) != 0))) { DebugAssert ( "/home/coreboot/node-root/workspace/coreboot_scanbuild/3rdparty/stm/Stm/StmPkg/EdkII/MdePkg/Library/BasePrintLib/PrintLibInternal.c" , 888, "(((Flags & 0x40) != 0)) || (AsciiStrSize (OriginalBuffer) != 0)" ); } } } while (((BOOLEAN)(0==1))); | |||
889 | ||||
890 | return ((Buffer - OriginalBuffer) / BytesPerOutputCharacter); | |||
891 | } | |||
892 | ||||
893 | /** | |||
894 | Worker function that produces a Null-terminated string in an output buffer | |||
895 | based on a Null-terminated format string and variable argument list. | |||
896 | ||||
897 | VSPrint function to process format and place the results in Buffer. Since a | |||
898 | VA_LIST is used this routine allows the nesting of Vararg routines. Thus | |||
899 | this is the main print working routine | |||
900 | ||||
901 | @param StartOfBuffer The character buffer to print the results of the parsing | |||
902 | of Format into. | |||
903 | @param BufferSize The maximum number of characters to put into buffer. | |||
904 | Zero means no limit. | |||
905 | @param Flags Initial flags value. | |||
906 | Can only have FORMAT_UNICODE and OUTPUT_UNICODE set | |||
907 | @param FormatString A Null-terminated format string. | |||
908 | @param ... The variable argument list. | |||
909 | ||||
910 | @return The number of characters printed. | |||
911 | ||||
912 | **/ | |||
913 | UINTN | |||
914 | EFIAPI | |||
915 | BasePrintLibSPrint ( | |||
916 | OUT CHAR8 *StartOfBuffer, | |||
917 | IN UINTN BufferSize, | |||
918 | IN UINTN Flags, | |||
919 | IN CONSTconst CHAR8 *FormatString, | |||
920 | ... | |||
921 | ) | |||
922 | { | |||
923 | VA_LIST Marker; | |||
924 | ||||
925 | VA_START (Marker, FormatString)__builtin_va_start (Marker, FormatString); | |||
926 | return BasePrintLibSPrintMarker (StartOfBuffer, BufferSize, Flags, FormatString, Marker, NULL((void *) 0)); | |||
927 | } |