UINTN USPrint ( OUT CHAR16 *Buffer, IN UINTN BufferSize, IN CONST CHAR16 *Format, ... ) /*++ Routine Description: Process format and place the results in Buffer for wide chars. Arguments: Buffer - Wide char buffer to print the results of the parsing of Format into. BufferSize - Maximum number of characters to put into buffer. Format - Format string ... - Vararg list consumed by processing Format. Returns: Number of characters printed. --*/ { UINTN Return; VA_LIST Marker; VA_START (Marker, Format); Return = UnicodeVSPrint (Buffer, BufferSize, Format, Marker); VA_END (Marker); return Return; }
/** Formatted Print using a Hii Token to reference the localized format string. @param[in] Token A HII token associated with a localized Unicode string. @param[in] ... The variable argument list. @return The number of characters converted by UnicodeVSPrint(). **/ UINTN EFIAPI PrintToken ( IN UINT16 Token, ... ) { VA_LIST Marker; EFI_STRING StringPtr; UINTN Return; UINTN BufferSize; StringPtr = HiiGetString (gHiiHandle, Token, NULL); ASSERT (StringPtr != NULL); VA_START (Marker, Token); BufferSize = (PcdGet32 (PcdUefiLibMaxPrintBufferSize) + 1) * sizeof (CHAR16); if (mPrintTokenBuffer == NULL) { mPrintTokenBuffer = AllocatePool (BufferSize); ASSERT (mPrintTokenBuffer != NULL); } SetMem( mPrintTokenBuffer, BufferSize, 0); Return = UnicodeVSPrint (mPrintTokenBuffer, BufferSize, StringPtr, Marker); VA_END (Marker); if (Return > 0 && gST->ConOut != NULL) { gST->ConOut->OutputString (gST->ConOut, mPrintTokenBuffer); } FreePool (StringPtr); return Return; }
/** Produces a Null-terminated Unicode string in an output buffer based on a Null-terminated Unicode format string and variable argument list. Produces a Null-terminated Unicode string in the output buffer specified by StartOfBuffer and BufferSize. The Unicode string is produced by parsing the format string specified by FormatString. Arguments are pulled from the variable argument list based on the contents of the format string. The number of Unicode characters in the produced output buffer is returned not including the Null-terminator. If BufferSize is 0 or 1, then no output buffer is produced and 0 is returned. If BufferSize > 1 and StartOfBuffer is NULL, then ASSERT(). If BufferSize > 1 and StartOfBuffer is not aligned on a 16-bit boundary, then ASSERT(). If BufferSize > 1 and FormatString is NULL, then ASSERT(). If BufferSize > 1 and FormatString is not aligned on a 16-bit boundary, then ASSERT(). If PcdMaximumUnicodeStringLength is not zero, and FormatString contains more than PcdMaximumUnicodeStringLength Unicode characters not including the Null-terminator, then ASSERT(). If PcdMaximumUnicodeStringLength is not zero, and produced Null-terminated Unicode string contains more than PcdMaximumUnicodeStringLength Unicode characters not including the Null-terminator, then ASSERT(). @param StartOfBuffer A pointer to the output buffer for the produced Null-terminated Unicode string. @param BufferSize The size, in bytes, of the output buffer specified by StartOfBuffer. @param FormatString A Null-terminated Unicode format string. @param ... Variable argument list whose contents are accessed based on the format string specified by FormatString. @return The number of Unicode characters in the produced output buffer not including the Null-terminator. **/ UINTN EFIAPI UnicodeSPrint ( OUT CHAR16 *StartOfBuffer, IN UINTN BufferSize, IN CONST CHAR16 *FormatString, ... ) { VA_LIST Marker; UINTN NumberOfPrinted; VA_START (Marker, FormatString); NumberOfPrinted = UnicodeVSPrint (StartOfBuffer, BufferSize, FormatString, Marker); VA_END (Marker); return NumberOfPrinted; }
EFIAPI CatPrint ( IN OUT POOL_PRINT *Str, IN CHAR16 *Fmt, ... ) { UINT16 *AppendStr; VA_LIST Args; UINTN StringSize; AppendStr = AllocateZeroPool (0x1000); if (AppendStr == NULL) { ASSERT(FALSE); return Str->Str; } VA_START (Args, Fmt); UnicodeVSPrint (AppendStr, 0x1000, Fmt, Args); VA_END (Args); if (NULL == Str->Str) { StringSize = StrSize (AppendStr); Str->Str = AllocateZeroPool (StringSize); ASSERT (Str->Str != NULL); } else { StringSize = StrSize (AppendStr); StringSize += (StrSize (Str->Str) - sizeof (UINT16)); Str->Str = ReallocatePool ( StrSize (Str->Str), StringSize, Str->Str ); ASSERT (Str->Str != NULL); } StrCat (Str->Str, AppendStr); Str->Len = StringSize; FreePool (AppendStr); return Str->Str; }
/** function to take a formatted argument and print it to a file. @param[in] Handle the file handle for the file to write to @param[in] Format the format argument (see printlib for format specifier) @param[in] ... the variable arguments for the format @retval EFI_SUCCESS the operation was successful @return other a return value from FileHandleWriteLine @sa FileHandleWriteLine **/ EFI_STATUS EFIAPI FileHandlePrintLine( IN EFI_FILE_HANDLE Handle, IN CONST CHAR16 *Format, ... ) { VA_LIST Marker; CHAR16 *Buffer; EFI_STATUS Status; // // Get a buffer to print into // Buffer = AllocateZeroPool (PcdGet16 (PcdUefiFileHandleLibPrintBufferSize)); if (Buffer == NULL) { return (EFI_OUT_OF_RESOURCES); } // // Print into our buffer // VA_START (Marker, Format); UnicodeVSPrint (Buffer, PcdGet16 (PcdUefiFileHandleLibPrintBufferSize), Format, Marker); VA_END (Marker); // // Print buffer into file // Status = FileHandleWriteLine(Handle, Buffer); // // Cleanup and return // FreePool(Buffer); return (Status); }
UINTN InternalPrintToken ( IN CONST CHAR16 *Format, IN EFI_SIMPLE_TEXT_OUTPUT_PROTOCOL *Console, IN VA_LIST Marker ) { EFI_STATUS Status; UINTN Return; CHAR16 *Buffer; UINTN BufferSize; ASSERT (Format != NULL); ASSERT (((UINTN) Format & BIT0) == 0); ASSERT (Console != NULL); BufferSize = (PcdGet32 (PcdUefiLibMaxPrintBufferSize) + 1) * sizeof (CHAR16); Buffer = (CHAR16 *) AllocatePool(BufferSize); ASSERT (Buffer != NULL); Return = UnicodeVSPrint (Buffer, BufferSize, Format, Marker); if (Console != NULL && Return > 0) { // // To be extra safe make sure Console has been initialized. // Status = Console->OutputString (Console, Buffer); if (EFI_ERROR (Status)) { Return = 0; } } FreePool (Buffer); return Return; }
/** The internal function prints to the EFI_SIMPLE_TEXT_OUTPUT_PROTOCOL protocol instance. @param Width Width of string to be print. @param Column The position of the output string. @param Row The position of the output string. @param Out The EFI_SIMPLE_TEXT_OUTPUT_PROTOCOL instance. @param Fmt The format string. @param Args The additional argument for the variables in the format string. @return Number of Unicode character printed. **/ UINTN PrintInternal ( IN UINTN Width, IN UINTN Column, IN UINTN Row, IN EFI_SIMPLE_TEXT_OUTPUT_PROTOCOL *Out, IN CHAR16 *Fmt, IN VA_LIST Args ) { CHAR16 *Buffer; CHAR16 *BackupBuffer; UINTN Index; UINTN PreviousIndex; UINTN Count; UINTN TotalCount; UINTN PrintWidth; UINTN CharWidth; // // For now, allocate an arbitrarily long buffer // Buffer = AllocateZeroPool (0x10000); BackupBuffer = AllocateZeroPool (0x10000); ASSERT (Buffer); ASSERT (BackupBuffer); if (Column != (UINTN) -1) { Out->SetCursorPosition (Out, Column, Row); } UnicodeVSPrint (Buffer, 0x10000, Fmt, Args); Out->Mode->Attribute = Out->Mode->Attribute & 0x7f; Out->SetAttribute (Out, Out->Mode->Attribute); Index = 0; PreviousIndex = 0; Count = 0; TotalCount = 0; PrintWidth = 0; CharWidth = 1; do { for (; (Buffer[Index] != NARROW_CHAR) && (Buffer[Index] != WIDE_CHAR) && (Buffer[Index] != 0); Index++) { BackupBuffer[Index] = Buffer[Index]; } if (Buffer[Index] == 0) { break; } // // Print this out, we are about to switch widths // Out->OutputString (Out, &BackupBuffer[PreviousIndex]); Count = StrLen (&BackupBuffer[PreviousIndex]); PrintWidth += Count * CharWidth; TotalCount += Count; // // Preserve the current index + 1, since this is where we will start printing from next // PreviousIndex = Index + 1; // // We are at a narrow or wide character directive. Set attributes and strip it and print it // if (Buffer[Index] == NARROW_CHAR) { // // Preserve bits 0 - 6 and zero out the rest // Out->Mode->Attribute = Out->Mode->Attribute & 0x7f; Out->SetAttribute (Out, Out->Mode->Attribute); CharWidth = 1; } else { // // Must be wide, set bit 7 ON // Out->Mode->Attribute = Out->Mode->Attribute | EFI_WIDE_ATTRIBUTE; Out->SetAttribute (Out, Out->Mode->Attribute); CharWidth = 2; } Index++; } while (Buffer[Index] != 0); // // We hit the end of the string - print it // Out->OutputString (Out, &BackupBuffer[PreviousIndex]); Count = StrLen (&BackupBuffer[PreviousIndex]); PrintWidth += Count * CharWidth; TotalCount += Count; if (PrintWidth < Width) { Out->Mode->Attribute = Out->Mode->Attribute & 0x7f; Out->SetAttribute (Out, Out->Mode->Attribute); Out->OutputString (Out, &mSpaceBuffer[SPACE_BUFFER_SIZE - Width + PrintWidth]); } FreePool (Buffer); FreePool (BackupBuffer); return TotalCount; }