mirror of
https://github.com/CloverHackyColor/CloverBootloader.git
synced 2024-12-05 13:33:33 +01:00
01f33f7552
stylish change: remove space between func and brace Signed-off-by: SergeySlice <sergey.slice@gmail.com>
2079 lines
75 KiB
C
2079 lines
75 KiB
C
/** @file
|
|
Implementation for EFI_HII_STRING_PROTOCOL.
|
|
|
|
|
|
Copyright (c) 2007 - 2018, Intel Corporation. All rights reserved.<BR>
|
|
(C) Copyright 2016 Hewlett Packard Enterprise Development LP<BR>
|
|
SPDX-License-Identifier: BSD-2-Clause-Patent
|
|
|
|
**/
|
|
|
|
|
|
#include "HiiDatabase.h"
|
|
|
|
CHAR16 mLanguageWindow[16] = {
|
|
0x0000, 0x0080, 0x0100, 0x0300,
|
|
0x2000, 0x2080, 0x2100, 0x3000,
|
|
0x0080, 0x00C0, 0x0400, 0x0600,
|
|
0x0900, 0x3040, 0x30A0, 0xFF00
|
|
};
|
|
|
|
|
|
/**
|
|
This function checks whether a global font info is referred by local
|
|
font info list or not. (i.e. HII_FONT_INFO is generated.) If not, create
|
|
a HII_FONT_INFO to refer it locally.
|
|
|
|
This is a internal function.
|
|
|
|
|
|
@param Private Hii database private structure.
|
|
@param StringPackage HII string package instance.
|
|
@param FontId Font identifer, which must be unique within the string package.
|
|
@param DuplicateEnable If true, duplicate HII_FONT_INFO which refers to
|
|
the same EFI_FONT_INFO is permitted. Otherwise it
|
|
is not allowed.
|
|
@param GlobalFontInfo Input a global font info which specify a
|
|
EFI_FONT_INFO.
|
|
@param LocalFontInfo Output a local font info which refers to a
|
|
EFI_FONT_INFO.
|
|
|
|
@retval TRUE Already referred before calling this function.
|
|
@retval FALSE Not referred before calling this function.
|
|
|
|
**/
|
|
BOOLEAN
|
|
ReferFontInfoLocally (
|
|
IN HII_DATABASE_PRIVATE_DATA *Private,
|
|
IN HII_STRING_PACKAGE_INSTANCE *StringPackage,
|
|
IN UINT8 FontId,
|
|
IN BOOLEAN DuplicateEnable,
|
|
IN HII_GLOBAL_FONT_INFO *GlobalFontInfo,
|
|
OUT HII_FONT_INFO **LocalFontInfo
|
|
)
|
|
{
|
|
HII_FONT_INFO *LocalFont;
|
|
LIST_ENTRY *Link;
|
|
|
|
ASSERT (Private != NULL && StringPackage != NULL && GlobalFontInfo != NULL && LocalFontInfo != NULL);
|
|
|
|
if (!DuplicateEnable) {
|
|
for (Link = StringPackage->FontInfoList.ForwardLink;
|
|
Link != &StringPackage->FontInfoList;
|
|
Link = Link->ForwardLink
|
|
) {
|
|
LocalFont = CR (Link, HII_FONT_INFO, Entry, HII_FONT_INFO_SIGNATURE);
|
|
if (LocalFont->GlobalEntry == &GlobalFontInfo->Entry) {
|
|
//
|
|
// Already referred by local font info list, return directly.
|
|
//
|
|
*LocalFontInfo = LocalFont;
|
|
return TRUE;
|
|
}
|
|
}
|
|
}
|
|
// FontId identifies EFI_FONT_INFO in local string package uniquely.
|
|
// GlobalEntry points to a HII_GLOBAL_FONT_INFO which identifies
|
|
// EFI_FONT_INFO uniquely in whole hii database.
|
|
//
|
|
LocalFont = (HII_FONT_INFO *) AllocateZeroPool (sizeof (HII_FONT_INFO));
|
|
ASSERT (LocalFont != NULL);
|
|
|
|
LocalFont->Signature = HII_FONT_INFO_SIGNATURE;
|
|
LocalFont->FontId = FontId;
|
|
LocalFont->GlobalEntry = &GlobalFontInfo->Entry;
|
|
InsertTailList (&StringPackage->FontInfoList, &LocalFont->Entry);
|
|
|
|
*LocalFontInfo = LocalFont;
|
|
return FALSE;
|
|
}
|
|
|
|
|
|
/**
|
|
Convert Ascii string text to unicode string test.
|
|
|
|
This is a internal function.
|
|
|
|
|
|
@param StringDest Buffer to store the string text. If it is NULL,
|
|
only the size will be returned.
|
|
@param StringSrc Points to current null-terminated string.
|
|
@param BufferSize Length of the buffer.
|
|
|
|
@retval EFI_SUCCESS The string text was outputted successfully.
|
|
@retval EFI_BUFFER_TOO_SMALL Buffer is insufficient to store the found string
|
|
text. BufferSize is updated to the required buffer
|
|
size.
|
|
|
|
**/
|
|
EFI_STATUS
|
|
ConvertToUnicodeText (
|
|
OUT EFI_STRING StringDest,
|
|
IN CHAR8 *StringSrc,
|
|
IN OUT UINTN *BufferSize
|
|
)
|
|
{
|
|
UINTN StringSize;
|
|
UINTN Index;
|
|
|
|
ASSERT (StringSrc != NULL && BufferSize != NULL);
|
|
|
|
StringSize = AsciiStrSize (StringSrc) * 2;
|
|
if (*BufferSize < StringSize || StringDest == NULL) {
|
|
*BufferSize = StringSize;
|
|
return EFI_BUFFER_TOO_SMALL;
|
|
}
|
|
|
|
for (Index = 0; Index < AsciiStrLen (StringSrc); Index++) {
|
|
StringDest[Index] = (CHAR16) StringSrc[Index];
|
|
}
|
|
|
|
StringDest[Index] = 0;
|
|
return EFI_SUCCESS;
|
|
}
|
|
|
|
|
|
/**
|
|
Calculate the size of StringSrc and output it. If StringDest is not NULL,
|
|
copy string text from src to dest.
|
|
|
|
This is a internal function.
|
|
|
|
@param StringDest Buffer to store the string text. If it is NULL,
|
|
only the size will be returned.
|
|
@param StringSrc Points to current null-terminated string.
|
|
@param BufferSize Length of the buffer.
|
|
|
|
@retval EFI_SUCCESS The string text was outputted successfully.
|
|
@retval EFI_BUFFER_TOO_SMALL Buffer is insufficient to store the found string
|
|
text. BufferSize is updated to the required buffer
|
|
size.
|
|
|
|
**/
|
|
EFI_STATUS
|
|
GetUnicodeStringTextOrSize (
|
|
OUT EFI_STRING StringDest, OPTIONAL
|
|
IN UINT8 *StringSrc,
|
|
IN OUT UINTN *BufferSize
|
|
)
|
|
{
|
|
UINTN StringSize;
|
|
UINT8 *StringPtr;
|
|
|
|
ASSERT (StringSrc != NULL && BufferSize != NULL);
|
|
|
|
StringSize = sizeof (CHAR16);
|
|
StringPtr = StringSrc;
|
|
while (ReadUnaligned16 ((UINT16 *) StringPtr) != 0) {
|
|
StringSize += sizeof (CHAR16);
|
|
StringPtr += sizeof (CHAR16);
|
|
}
|
|
|
|
if (*BufferSize < StringSize) {
|
|
*BufferSize = StringSize;
|
|
return EFI_BUFFER_TOO_SMALL;
|
|
}
|
|
if (StringDest != NULL) {
|
|
CopyMem (StringDest, StringSrc, StringSize);
|
|
}
|
|
|
|
*BufferSize = StringSize;
|
|
return EFI_SUCCESS;
|
|
}
|
|
|
|
|
|
/**
|
|
Copy string font info to a buffer.
|
|
|
|
This is a internal function.
|
|
|
|
@param StringPackage Hii string package instance.
|
|
@param FontId Font identifier which is unique in a string
|
|
package.
|
|
@param StringFontInfo Buffer to record the output font info. It's
|
|
caller's responsibility to free this buffer.
|
|
|
|
@retval EFI_SUCCESS The string font is outputted successfully.
|
|
@retval EFI_NOT_FOUND The specified font id does not exist.
|
|
|
|
**/
|
|
EFI_STATUS
|
|
GetStringFontInfo (
|
|
IN HII_STRING_PACKAGE_INSTANCE *StringPackage,
|
|
IN UINT8 FontId,
|
|
OUT EFI_FONT_INFO **StringFontInfo
|
|
)
|
|
{
|
|
LIST_ENTRY *Link;
|
|
HII_FONT_INFO *FontInfo;
|
|
HII_GLOBAL_FONT_INFO *GlobalFont;
|
|
|
|
ASSERT (StringFontInfo != NULL && StringPackage != NULL);
|
|
|
|
for (Link = StringPackage->FontInfoList.ForwardLink; Link != &StringPackage->FontInfoList; Link = Link->ForwardLink) {
|
|
FontInfo = CR (Link, HII_FONT_INFO, Entry, HII_FONT_INFO_SIGNATURE);
|
|
if (FontInfo->FontId == FontId) {
|
|
GlobalFont = CR (FontInfo->GlobalEntry, HII_GLOBAL_FONT_INFO, Entry, HII_GLOBAL_FONT_INFO_SIGNATURE);
|
|
*StringFontInfo = (EFI_FONT_INFO *) AllocateZeroPool (GlobalFont->FontInfoSize);
|
|
if (*StringFontInfo == NULL) {
|
|
return EFI_OUT_OF_RESOURCES;
|
|
}
|
|
CopyMem (*StringFontInfo, GlobalFont->FontInfo, GlobalFont->FontInfoSize);
|
|
return EFI_SUCCESS;
|
|
}
|
|
}
|
|
|
|
return EFI_NOT_FOUND;
|
|
}
|
|
|
|
|
|
/**
|
|
Parse all string blocks to find a String block specified by StringId.
|
|
If StringId = (EFI_STRING_ID) (-1), find out all EFI_HII_SIBT_FONT blocks
|
|
within this string package and backup its information. If LastStringId is
|
|
specified, the string id of last string block will also be output.
|
|
If StringId = 0, output the string id of last string block (EFI_HII_SIBT_STRING).
|
|
|
|
@param Private Hii database private structure.
|
|
@param StringPackage Hii string package instance.
|
|
@param StringId The string's id, which is unique within
|
|
PackageList.
|
|
@param BlockType Output the block type of found string block.
|
|
@param StringBlockAddr Output the block address of found string block.
|
|
@param StringTextOffset Offset, relative to the found block address, of
|
|
the string text information.
|
|
@param LastStringId Output the last string id when StringId = 0 or StringId = -1.
|
|
@param StartStringId The first id in the skip block which StringId in the block.
|
|
|
|
@retval EFI_SUCCESS The string text and font is retrieved
|
|
successfully.
|
|
@retval EFI_NOT_FOUND The specified text or font info can not be found
|
|
out.
|
|
@retval EFI_OUT_OF_RESOURCES The system is out of resources to accomplish the
|
|
task.
|
|
|
|
**/
|
|
EFI_STATUS
|
|
FindStringBlock (
|
|
IN HII_DATABASE_PRIVATE_DATA *Private,
|
|
IN HII_STRING_PACKAGE_INSTANCE *StringPackage,
|
|
IN EFI_STRING_ID StringId,
|
|
OUT UINT8 *BlockType, OPTIONAL
|
|
OUT UINT8 **StringBlockAddr, OPTIONAL
|
|
OUT UINTN *StringTextOffset, OPTIONAL
|
|
OUT EFI_STRING_ID *LastStringId, OPTIONAL
|
|
OUT EFI_STRING_ID *StartStringId OPTIONAL
|
|
)
|
|
{
|
|
UINT8 *BlockHdr;
|
|
EFI_STRING_ID CurrentStringId;
|
|
UINTN BlockSize;
|
|
UINTN Index;
|
|
UINT8 *StringTextPtr;
|
|
UINTN Offset;
|
|
HII_FONT_INFO *LocalFont;
|
|
EFI_FONT_INFO *FontInfo;
|
|
HII_GLOBAL_FONT_INFO *GlobalFont;
|
|
UINTN FontInfoSize;
|
|
UINT16 StringCount;
|
|
UINT16 SkipCount;
|
|
EFI_HII_FONT_STYLE FontStyle;
|
|
UINT16 FontSize;
|
|
UINT8 Length8;
|
|
EFI_HII_SIBT_EXT2_BLOCK Ext2;
|
|
UINT8 FontId;
|
|
UINT32 Length32;
|
|
UINTN StringSize;
|
|
CHAR16 Zero;
|
|
|
|
ASSERT (StringPackage != NULL);
|
|
ASSERT (StringPackage->Signature == HII_STRING_PACKAGE_SIGNATURE);
|
|
|
|
CurrentStringId = 1;
|
|
StringSize = 0;
|
|
|
|
if (StringId != (EFI_STRING_ID) (-1) && StringId != 0) {
|
|
ASSERT (BlockType != NULL && StringBlockAddr != NULL && StringTextOffset != NULL);
|
|
if (StringId > StringPackage->MaxStringId) {
|
|
return EFI_NOT_FOUND;
|
|
}
|
|
} else {
|
|
ASSERT (Private != NULL && Private->Signature == HII_DATABASE_PRIVATE_DATA_SIGNATURE);
|
|
if (StringId == 0 && LastStringId != NULL) {
|
|
*LastStringId = StringPackage->MaxStringId;
|
|
return EFI_SUCCESS;
|
|
}
|
|
}
|
|
|
|
ZeroMem (&Zero, sizeof (CHAR16));
|
|
|
|
//
|
|
// Parse the string blocks to get the string text and font.
|
|
//
|
|
BlockHdr = StringPackage->StringBlock;
|
|
BlockSize = 0;
|
|
Offset = 0;
|
|
while (*BlockHdr != EFI_HII_SIBT_END) {
|
|
switch (*BlockHdr) {
|
|
case EFI_HII_SIBT_STRING_SCSU:
|
|
Offset = sizeof (EFI_HII_STRING_BLOCK);
|
|
StringTextPtr = BlockHdr + Offset;
|
|
BlockSize += Offset + AsciiStrSize ((CHAR8 *) StringTextPtr);
|
|
CurrentStringId++;
|
|
break;
|
|
|
|
case EFI_HII_SIBT_STRING_SCSU_FONT:
|
|
Offset = sizeof (EFI_HII_SIBT_STRING_SCSU_FONT_BLOCK) - sizeof (UINT8);
|
|
StringTextPtr = BlockHdr + Offset;
|
|
BlockSize += Offset + AsciiStrSize ((CHAR8 *) StringTextPtr);
|
|
CurrentStringId++;
|
|
break;
|
|
|
|
case EFI_HII_SIBT_STRINGS_SCSU:
|
|
CopyMem (&StringCount, BlockHdr + sizeof (EFI_HII_STRING_BLOCK), sizeof (UINT16));
|
|
StringTextPtr = (UINT8*)((UINTN)BlockHdr + sizeof (EFI_HII_SIBT_STRINGS_SCSU_BLOCK) - sizeof (UINT8));
|
|
BlockSize += StringTextPtr - BlockHdr;
|
|
|
|
for (Index = 0; Index < StringCount; Index++) {
|
|
BlockSize += AsciiStrSize ((CHAR8 *) StringTextPtr);
|
|
if (CurrentStringId == StringId) {
|
|
ASSERT (BlockType != NULL && StringBlockAddr != NULL && StringTextOffset != NULL);
|
|
*BlockType = *BlockHdr;
|
|
*StringBlockAddr = BlockHdr;
|
|
*StringTextOffset = StringTextPtr - BlockHdr;
|
|
return EFI_SUCCESS;
|
|
}
|
|
StringTextPtr = StringTextPtr + AsciiStrSize ((CHAR8 *) StringTextPtr);
|
|
CurrentStringId++;
|
|
}
|
|
break;
|
|
|
|
case EFI_HII_SIBT_STRINGS_SCSU_FONT:
|
|
CopyMem (
|
|
&StringCount,
|
|
(UINT8*)((UINTN)BlockHdr + sizeof (EFI_HII_STRING_BLOCK) + sizeof (UINT8)),
|
|
sizeof (UINT16)
|
|
);
|
|
StringTextPtr = (UINT8*)((UINTN)BlockHdr + sizeof (EFI_HII_SIBT_STRINGS_SCSU_FONT_BLOCK) - sizeof (UINT8));
|
|
BlockSize += StringTextPtr - BlockHdr;
|
|
|
|
for (Index = 0; Index < StringCount; Index++) {
|
|
BlockSize += AsciiStrSize ((CHAR8 *) StringTextPtr);
|
|
if (CurrentStringId == StringId) {
|
|
ASSERT (BlockType != NULL && StringBlockAddr != NULL && StringTextOffset != NULL);
|
|
*BlockType = *BlockHdr;
|
|
*StringBlockAddr = BlockHdr;
|
|
*StringTextOffset = StringTextPtr - BlockHdr;
|
|
return EFI_SUCCESS;
|
|
}
|
|
StringTextPtr = StringTextPtr + AsciiStrSize ((CHAR8 *) StringTextPtr);
|
|
CurrentStringId++;
|
|
}
|
|
break;
|
|
|
|
case EFI_HII_SIBT_STRING_UCS2:
|
|
Offset = sizeof (EFI_HII_STRING_BLOCK);
|
|
StringTextPtr = BlockHdr + Offset;
|
|
//
|
|
// Use StringSize to store the size of the specified string, including the NULL
|
|
// terminator.
|
|
//
|
|
GetUnicodeStringTextOrSize (NULL, StringTextPtr, &StringSize);
|
|
BlockSize += Offset + StringSize;
|
|
CurrentStringId++;
|
|
break;
|
|
|
|
case EFI_HII_SIBT_STRING_UCS2_FONT:
|
|
Offset = sizeof (EFI_HII_SIBT_STRING_UCS2_FONT_BLOCK) - sizeof (CHAR16);
|
|
StringTextPtr = BlockHdr + Offset;
|
|
//
|
|
// Use StrSize to store the size of the specified string, including the NULL
|
|
// terminator.
|
|
//
|
|
GetUnicodeStringTextOrSize (NULL, StringTextPtr, &StringSize);
|
|
BlockSize += Offset + StringSize;
|
|
CurrentStringId++;
|
|
break;
|
|
|
|
case EFI_HII_SIBT_STRINGS_UCS2:
|
|
Offset = sizeof (EFI_HII_SIBT_STRINGS_UCS2_BLOCK) - sizeof (CHAR16);
|
|
StringTextPtr = BlockHdr + Offset;
|
|
BlockSize += Offset;
|
|
CopyMem (&StringCount, BlockHdr + sizeof (EFI_HII_STRING_BLOCK), sizeof (UINT16));
|
|
for (Index = 0; Index < StringCount; Index++) {
|
|
GetUnicodeStringTextOrSize (NULL, StringTextPtr, &StringSize);
|
|
BlockSize += StringSize;
|
|
if (CurrentStringId == StringId) {
|
|
ASSERT (BlockType != NULL && StringBlockAddr != NULL && StringTextOffset != NULL);
|
|
*BlockType = *BlockHdr;
|
|
*StringBlockAddr = BlockHdr;
|
|
*StringTextOffset = StringTextPtr - BlockHdr;
|
|
return EFI_SUCCESS;
|
|
}
|
|
StringTextPtr = StringTextPtr + StringSize;
|
|
CurrentStringId++;
|
|
}
|
|
break;
|
|
|
|
case EFI_HII_SIBT_STRINGS_UCS2_FONT:
|
|
Offset = sizeof (EFI_HII_SIBT_STRINGS_UCS2_FONT_BLOCK) - sizeof (CHAR16);
|
|
StringTextPtr = BlockHdr + Offset;
|
|
BlockSize += Offset;
|
|
CopyMem (
|
|
&StringCount,
|
|
(UINT8*)((UINTN)BlockHdr + sizeof (EFI_HII_STRING_BLOCK) + sizeof (UINT8)),
|
|
sizeof (UINT16)
|
|
);
|
|
for (Index = 0; Index < StringCount; Index++) {
|
|
GetUnicodeStringTextOrSize (NULL, StringTextPtr, &StringSize);
|
|
BlockSize += StringSize;
|
|
if (CurrentStringId == StringId) {
|
|
ASSERT (BlockType != NULL && StringBlockAddr != NULL && StringTextOffset != NULL);
|
|
*BlockType = *BlockHdr;
|
|
*StringBlockAddr = BlockHdr;
|
|
*StringTextOffset = StringTextPtr - BlockHdr;
|
|
return EFI_SUCCESS;
|
|
}
|
|
StringTextPtr = StringTextPtr + StringSize;
|
|
CurrentStringId++;
|
|
}
|
|
break;
|
|
|
|
case EFI_HII_SIBT_DUPLICATE:
|
|
if (CurrentStringId == StringId) {
|
|
//
|
|
// Incoming StringId is an id of a duplicate string block.
|
|
// Update the StringId to be the previous string block.
|
|
// Go back to the header of string block to search.
|
|
//
|
|
CopyMem (
|
|
&StringId,
|
|
BlockHdr + sizeof (EFI_HII_STRING_BLOCK),
|
|
sizeof (EFI_STRING_ID)
|
|
);
|
|
ASSERT (StringId != CurrentStringId);
|
|
CurrentStringId = 1;
|
|
BlockSize = 0;
|
|
} else {
|
|
BlockSize += sizeof (EFI_HII_SIBT_DUPLICATE_BLOCK);
|
|
CurrentStringId++;
|
|
}
|
|
break;
|
|
|
|
case EFI_HII_SIBT_SKIP1:
|
|
SkipCount = (UINT16) (*(UINT8*)((UINTN)BlockHdr + sizeof (EFI_HII_STRING_BLOCK)));
|
|
CurrentStringId = (UINT16) (CurrentStringId + SkipCount);
|
|
BlockSize += sizeof (EFI_HII_SIBT_SKIP1_BLOCK);
|
|
break;
|
|
|
|
case EFI_HII_SIBT_SKIP2:
|
|
CopyMem (&SkipCount, BlockHdr + sizeof (EFI_HII_STRING_BLOCK), sizeof (UINT16));
|
|
CurrentStringId = (UINT16) (CurrentStringId + SkipCount);
|
|
BlockSize += sizeof (EFI_HII_SIBT_SKIP2_BLOCK);
|
|
break;
|
|
|
|
case EFI_HII_SIBT_EXT1:
|
|
CopyMem (
|
|
&Length8,
|
|
(UINT8*)((UINTN)BlockHdr + sizeof (EFI_HII_STRING_BLOCK) + sizeof (UINT8)),
|
|
sizeof (UINT8)
|
|
);
|
|
BlockSize += Length8;
|
|
break;
|
|
|
|
case EFI_HII_SIBT_EXT2:
|
|
CopyMem (&Ext2, BlockHdr, sizeof (EFI_HII_SIBT_EXT2_BLOCK));
|
|
if (Ext2.BlockType2 == EFI_HII_SIBT_FONT && StringId == (EFI_STRING_ID) (-1)) {
|
|
//
|
|
// Find the relationship between global font info and the font info of
|
|
// this EFI_HII_SIBT_FONT block then backup its information in local package.
|
|
//
|
|
BlockHdr += sizeof (EFI_HII_SIBT_EXT2_BLOCK);
|
|
CopyMem (&FontId, BlockHdr, sizeof (UINT8));
|
|
BlockHdr ++;
|
|
CopyMem (&FontSize, BlockHdr, sizeof (UINT16));
|
|
BlockHdr += sizeof (UINT16);
|
|
CopyMem (&FontStyle, BlockHdr, sizeof (EFI_HII_FONT_STYLE));
|
|
BlockHdr += sizeof (EFI_HII_FONT_STYLE);
|
|
GetUnicodeStringTextOrSize (NULL, BlockHdr, &StringSize);
|
|
|
|
FontInfoSize = sizeof (EFI_FONT_INFO) - sizeof (CHAR16) + StringSize;
|
|
FontInfo = (EFI_FONT_INFO *) AllocateZeroPool (FontInfoSize);
|
|
if (FontInfo == NULL) {
|
|
return EFI_OUT_OF_RESOURCES;
|
|
}
|
|
FontInfo->FontStyle = FontStyle;
|
|
FontInfo->FontSize = FontSize;
|
|
CopyMem (FontInfo->FontName, BlockHdr, StringSize);
|
|
|
|
//
|
|
// If find the corresponding global font info, save the relationship.
|
|
// Otherwise ignore this EFI_HII_SIBT_FONT block.
|
|
//
|
|
if (IsFontInfoExisted (Private, FontInfo, NULL, NULL, &GlobalFont)) {
|
|
ReferFontInfoLocally (Private, StringPackage, FontId, TRUE, GlobalFont, &LocalFont);
|
|
}
|
|
|
|
//
|
|
// Since string package tool set FontId initially to 0 and increases it
|
|
// progressively by one, StringPackage->FondId always represents an unique
|
|
// and available FontId.
|
|
//
|
|
StringPackage->FontId++;
|
|
|
|
FreePool(FontInfo);
|
|
}
|
|
|
|
BlockSize += Ext2.Length;
|
|
|
|
break;
|
|
|
|
case EFI_HII_SIBT_EXT4:
|
|
CopyMem (
|
|
&Length32,
|
|
(UINT8*)((UINTN)BlockHdr + sizeof (EFI_HII_STRING_BLOCK) + sizeof (UINT8)),
|
|
sizeof (UINT32)
|
|
);
|
|
|
|
BlockSize += Length32;
|
|
break;
|
|
|
|
default:
|
|
break;
|
|
}
|
|
|
|
if (StringId > 0 && StringId != (EFI_STRING_ID)(-1)) {
|
|
ASSERT (BlockType != NULL && StringBlockAddr != NULL && StringTextOffset != NULL);
|
|
*BlockType = *BlockHdr;
|
|
*StringBlockAddr = BlockHdr;
|
|
*StringTextOffset = Offset;
|
|
|
|
if (StringId == CurrentStringId - 1) {
|
|
//
|
|
// if only one skip item, return EFI_NOT_FOUND.
|
|
//
|
|
if(*BlockType == EFI_HII_SIBT_SKIP2 || *BlockType == EFI_HII_SIBT_SKIP1) {
|
|
return EFI_NOT_FOUND;
|
|
} else {
|
|
return EFI_SUCCESS;
|
|
}
|
|
}
|
|
|
|
if (StringId < CurrentStringId - 1) {
|
|
return EFI_NOT_FOUND;
|
|
}
|
|
}
|
|
BlockHdr = StringPackage->StringBlock + BlockSize;
|
|
if (StartStringId != NULL) {
|
|
*StartStringId = CurrentStringId;
|
|
}
|
|
}
|
|
|
|
//
|
|
// Get last string ID
|
|
//
|
|
if (StringId == (EFI_STRING_ID) (-1) && LastStringId != NULL) {
|
|
*LastStringId = (EFI_STRING_ID) (CurrentStringId - 1);
|
|
return EFI_SUCCESS;
|
|
}
|
|
|
|
return EFI_NOT_FOUND;
|
|
}
|
|
|
|
|
|
/**
|
|
Parse all string blocks to get a string specified by StringId.
|
|
|
|
This is a internal function.
|
|
|
|
@param Private Hii database private structure.
|
|
@param StringPackage Hii string package instance.
|
|
@param StringId The string's id, which is unique within
|
|
PackageList.
|
|
@param String Points to retrieved null-terminated string.
|
|
@param StringSize On entry, points to the size of the buffer pointed
|
|
to by String, in bytes. On return, points to the
|
|
length of the string, in bytes.
|
|
@param StringFontInfo If not NULL, allocate a buffer to record the
|
|
output font info. It's caller's responsibility to
|
|
free this buffer.
|
|
|
|
@retval EFI_SUCCESS The string text and font is retrieved
|
|
successfully.
|
|
@retval EFI_NOT_FOUND The specified text or font info can not be found
|
|
out.
|
|
@retval EFI_BUFFER_TOO_SMALL The buffer specified by StringSize is too small to
|
|
hold the string.
|
|
|
|
**/
|
|
EFI_STATUS
|
|
GetStringWorker (
|
|
IN HII_DATABASE_PRIVATE_DATA *Private,
|
|
IN HII_STRING_PACKAGE_INSTANCE *StringPackage,
|
|
IN EFI_STRING_ID StringId,
|
|
OUT EFI_STRING String,
|
|
IN OUT UINTN *StringSize, OPTIONAL
|
|
OUT EFI_FONT_INFO **StringFontInfo OPTIONAL
|
|
)
|
|
{
|
|
UINT8 *StringTextPtr;
|
|
UINT8 BlockType;
|
|
UINT8 *StringBlockAddr;
|
|
UINTN StringTextOffset;
|
|
EFI_STATUS Status;
|
|
UINT8 FontId;
|
|
|
|
ASSERT (StringPackage != NULL);
|
|
ASSERT (Private != NULL && Private->Signature == HII_DATABASE_PRIVATE_DATA_SIGNATURE);
|
|
|
|
//
|
|
// Find the specified string block
|
|
//
|
|
Status = FindStringBlock (
|
|
Private,
|
|
StringPackage,
|
|
StringId,
|
|
&BlockType,
|
|
&StringBlockAddr,
|
|
&StringTextOffset,
|
|
NULL,
|
|
NULL
|
|
);
|
|
if (EFI_ERROR(Status)) {
|
|
return Status;
|
|
}
|
|
|
|
if (StringSize == NULL) {
|
|
//
|
|
// String text buffer is not requested
|
|
//
|
|
return EFI_SUCCESS;
|
|
}
|
|
|
|
//
|
|
// Get the string text.
|
|
//
|
|
StringTextPtr = StringBlockAddr + StringTextOffset;
|
|
switch (BlockType) {
|
|
case EFI_HII_SIBT_STRING_SCSU:
|
|
case EFI_HII_SIBT_STRING_SCSU_FONT:
|
|
case EFI_HII_SIBT_STRINGS_SCSU:
|
|
case EFI_HII_SIBT_STRINGS_SCSU_FONT:
|
|
Status = ConvertToUnicodeText (String, (CHAR8 *) StringTextPtr, StringSize);
|
|
break;
|
|
case EFI_HII_SIBT_STRING_UCS2:
|
|
case EFI_HII_SIBT_STRING_UCS2_FONT:
|
|
case EFI_HII_SIBT_STRINGS_UCS2:
|
|
case EFI_HII_SIBT_STRINGS_UCS2_FONT:
|
|
Status = GetUnicodeStringTextOrSize (String, StringTextPtr, StringSize);
|
|
break;
|
|
default:
|
|
return EFI_NOT_FOUND;
|
|
}
|
|
if (EFI_ERROR(Status)) {
|
|
return Status;
|
|
}
|
|
|
|
//
|
|
// Get the string font. The FontId 0 is the default font for those string blocks which
|
|
// do not specify a font identifier. If default font is not specified, return NULL.
|
|
//
|
|
if (StringFontInfo != NULL) {
|
|
switch (BlockType) {
|
|
case EFI_HII_SIBT_STRING_SCSU_FONT:
|
|
case EFI_HII_SIBT_STRINGS_SCSU_FONT:
|
|
case EFI_HII_SIBT_STRING_UCS2_FONT:
|
|
case EFI_HII_SIBT_STRINGS_UCS2_FONT:
|
|
FontId = *(StringBlockAddr + sizeof (EFI_HII_STRING_BLOCK));
|
|
break;
|
|
default:
|
|
FontId = 0;
|
|
}
|
|
Status = GetStringFontInfo (StringPackage, FontId, StringFontInfo);
|
|
if (Status == EFI_NOT_FOUND) {
|
|
*StringFontInfo = NULL;
|
|
}
|
|
}
|
|
|
|
return EFI_SUCCESS;
|
|
}
|
|
|
|
/**
|
|
If GetStringBlock find the StringId's string is not saved in the exist string block,
|
|
this function will create the UCS2 string block to save the string; also split the
|
|
skip block into two or one skip block.
|
|
|
|
This is a internal function.
|
|
|
|
@param StringPackage Hii string package instance.
|
|
@param StartStringId The first id in the skip block which StringId in the block.
|
|
@param StringId The string's id, which is unique within
|
|
PackageList.
|
|
@param BlockType Output the block type of found string block.
|
|
@param StringBlockAddr Output the block address of found string block.
|
|
@param FontBlock whether this string block has font info.
|
|
|
|
@retval EFI_SUCCESS The string font is outputted successfully.
|
|
@retval EFI_OUT_OF_RESOURCES NO resource for the memory to save the new string block.
|
|
|
|
**/
|
|
EFI_STATUS
|
|
InsertLackStringBlock (
|
|
IN OUT HII_STRING_PACKAGE_INSTANCE *StringPackage,
|
|
IN EFI_STRING_ID StartStringId,
|
|
IN EFI_STRING_ID StringId,
|
|
IN OUT UINT8 *BlockType,
|
|
IN OUT UINT8 **StringBlockAddr,
|
|
IN BOOLEAN FontBlock
|
|
)
|
|
{
|
|
UINT8 *BlockPtr;
|
|
UINT8 *StringBlock;
|
|
UINT32 SkipLen;
|
|
UINT32 OldBlockSize;
|
|
UINT32 NewBlockSize;
|
|
UINT32 FrontSkipNum;
|
|
UINT32 NewUCSBlockLen;
|
|
UINT8 *OldStringAddr;
|
|
UINT32 IdCount;
|
|
|
|
FrontSkipNum = 0;
|
|
SkipLen = 0;
|
|
OldStringAddr = *StringBlockAddr;
|
|
|
|
ASSERT (*BlockType == EFI_HII_SIBT_SKIP1 || *BlockType == EFI_HII_SIBT_SKIP2);
|
|
//
|
|
// Old skip block size.
|
|
//
|
|
if (*BlockType == EFI_HII_SIBT_SKIP1) {
|
|
SkipLen = sizeof (EFI_HII_SIBT_SKIP1_BLOCK);
|
|
IdCount = *(UINT8*)(OldStringAddr + sizeof (EFI_HII_STRING_BLOCK));
|
|
} else {
|
|
SkipLen = sizeof (EFI_HII_SIBT_SKIP2_BLOCK);
|
|
IdCount = *(UINT16*)(OldStringAddr + sizeof (EFI_HII_STRING_BLOCK));
|
|
}
|
|
|
|
//
|
|
// New create UCS or UCS2 block size.
|
|
//
|
|
if (FontBlock) {
|
|
NewUCSBlockLen = sizeof (EFI_HII_SIBT_STRING_UCS2_FONT_BLOCK);
|
|
} else {
|
|
NewUCSBlockLen = sizeof (EFI_HII_SIBT_STRING_UCS2_BLOCK);
|
|
}
|
|
|
|
OldBlockSize = StringPackage->StringPkgHdr->Header.Length - StringPackage->StringPkgHdr->HdrSize;
|
|
|
|
if (StartStringId == StringId) {
|
|
//
|
|
// New block + [Skip block]
|
|
//
|
|
if (IdCount > 1) {
|
|
NewBlockSize = OldBlockSize + NewUCSBlockLen;
|
|
} else {
|
|
NewBlockSize = OldBlockSize + NewUCSBlockLen - SkipLen;
|
|
}
|
|
} else if (StartStringId + IdCount - 1 == StringId){
|
|
//
|
|
// Skip block + New block
|
|
//
|
|
NewBlockSize = OldBlockSize + NewUCSBlockLen;
|
|
FrontSkipNum = StringId - StartStringId;
|
|
} else {
|
|
//
|
|
// Skip block + New block + [Skip block]
|
|
//
|
|
NewBlockSize = OldBlockSize + NewUCSBlockLen + SkipLen;
|
|
FrontSkipNum = StringId - StartStringId;
|
|
}
|
|
|
|
StringBlock = (UINT8 *) AllocateZeroPool (NewBlockSize);
|
|
if (StringBlock == NULL) {
|
|
return EFI_OUT_OF_RESOURCES;
|
|
}
|
|
|
|
//
|
|
// Copy old block in front of skip block.
|
|
//
|
|
CopyMem (StringBlock, StringPackage->StringBlock, OldStringAddr - StringPackage->StringBlock);
|
|
BlockPtr = StringBlock + (OldStringAddr - StringPackage->StringBlock);
|
|
|
|
if (FrontSkipNum > 0) {
|
|
*BlockPtr = *BlockType;
|
|
if (*BlockType == EFI_HII_SIBT_SKIP1) {
|
|
*(BlockPtr + sizeof (EFI_HII_STRING_BLOCK)) = (UINT8) FrontSkipNum;
|
|
} else {
|
|
*(UINT16 *)(BlockPtr + sizeof (EFI_HII_STRING_BLOCK)) = (UINT16) FrontSkipNum;
|
|
}
|
|
BlockPtr += SkipLen;
|
|
}
|
|
|
|
//
|
|
// Create a EFI_HII_SIBT_STRING_UCS2_FONT_BLOCK
|
|
//
|
|
*StringBlockAddr = BlockPtr;
|
|
if (FontBlock) {
|
|
*BlockPtr = EFI_HII_SIBT_STRING_UCS2_FONT;
|
|
} else {
|
|
*BlockPtr = EFI_HII_SIBT_STRING_UCS2;
|
|
}
|
|
BlockPtr += NewUCSBlockLen;
|
|
|
|
if (IdCount > FrontSkipNum + 1) {
|
|
*BlockPtr = *BlockType;
|
|
if (*BlockType == EFI_HII_SIBT_SKIP1) {
|
|
*(BlockPtr + sizeof (EFI_HII_STRING_BLOCK)) = (UINT8) (IdCount - FrontSkipNum - 1);
|
|
} else {
|
|
*(UINT16 *)(BlockPtr + sizeof (EFI_HII_STRING_BLOCK)) = (UINT16) (IdCount - FrontSkipNum - 1);
|
|
}
|
|
BlockPtr += SkipLen;
|
|
}
|
|
|
|
//
|
|
// Append a EFI_HII_SIBT_END block to the end.
|
|
//
|
|
CopyMem (BlockPtr, OldStringAddr + SkipLen, OldBlockSize - (OldStringAddr - StringPackage->StringBlock) - SkipLen);
|
|
|
|
if (FontBlock) {
|
|
*BlockType = EFI_HII_SIBT_STRING_UCS2_FONT;
|
|
} else {
|
|
*BlockType = EFI_HII_SIBT_STRING_UCS2;
|
|
}
|
|
FreePool(StringPackage->StringBlock);
|
|
StringPackage->StringBlock = StringBlock;
|
|
StringPackage->StringPkgHdr->Header.Length += NewBlockSize - OldBlockSize;
|
|
|
|
return EFI_SUCCESS;
|
|
}
|
|
|
|
/**
|
|
Parse all string blocks to set a String specified by StringId.
|
|
|
|
This is a internal function.
|
|
|
|
@param Private HII database driver private structure.
|
|
@param StringPackage HII string package instance.
|
|
@param StringId The string's id, which is unique within
|
|
PackageList.
|
|
@param String Points to the new null-terminated string.
|
|
@param StringFontInfo Points to the input font info.
|
|
|
|
@retval EFI_SUCCESS The string was updated successfully.
|
|
@retval EFI_NOT_FOUND The string specified by StringId is not in the
|
|
database.
|
|
@retval EFI_INVALID_PARAMETER The String or Language was NULL.
|
|
@retval EFI_INVALID_PARAMETER The specified StringFontInfo does not exist in
|
|
current database.
|
|
@retval EFI_OUT_OF_RESOURCES The system is out of resources to accomplish the
|
|
task.
|
|
|
|
**/
|
|
EFI_STATUS
|
|
SetStringWorker (
|
|
IN HII_DATABASE_PRIVATE_DATA *Private,
|
|
IN OUT HII_STRING_PACKAGE_INSTANCE *StringPackage,
|
|
IN EFI_STRING_ID StringId,
|
|
IN EFI_STRING String,
|
|
IN EFI_FONT_INFO *StringFontInfo OPTIONAL
|
|
)
|
|
{
|
|
UINT8 *StringTextPtr;
|
|
UINT8 BlockType;
|
|
UINT8 *StringBlockAddr;
|
|
UINTN StringTextOffset;
|
|
EFI_STATUS Status;
|
|
UINT8 *Block;
|
|
UINT8 *BlockPtr;
|
|
UINTN BlockSize;
|
|
UINTN OldBlockSize;
|
|
HII_FONT_INFO *LocalFont;
|
|
HII_GLOBAL_FONT_INFO *GlobalFont;
|
|
BOOLEAN Referred;
|
|
EFI_HII_SIBT_EXT2_BLOCK Ext2;
|
|
UINTN StringSize;
|
|
UINTN TmpSize;
|
|
EFI_STRING_ID StartStringId;
|
|
|
|
StartStringId = 0;
|
|
StringSize = 0;
|
|
ASSERT (Private != NULL && StringPackage != NULL && String != NULL);
|
|
ASSERT (Private->Signature == HII_DATABASE_PRIVATE_DATA_SIGNATURE);
|
|
//
|
|
// Find the specified string block
|
|
//
|
|
Status = FindStringBlock (
|
|
Private,
|
|
StringPackage,
|
|
StringId,
|
|
&BlockType,
|
|
&StringBlockAddr,
|
|
&StringTextOffset,
|
|
NULL,
|
|
&StartStringId
|
|
);
|
|
if (EFI_ERROR(Status) && (BlockType == EFI_HII_SIBT_SKIP1 || BlockType == EFI_HII_SIBT_SKIP2)) {
|
|
Status = InsertLackStringBlock(StringPackage,
|
|
StartStringId,
|
|
StringId,
|
|
&BlockType,
|
|
&StringBlockAddr,
|
|
(BOOLEAN)(StringFontInfo != NULL)
|
|
);
|
|
if (EFI_ERROR(Status)) {
|
|
return Status;
|
|
}
|
|
if (StringFontInfo != NULL) {
|
|
StringTextOffset = sizeof (EFI_HII_SIBT_STRING_UCS2_FONT_BLOCK) - sizeof (CHAR16);
|
|
} else {
|
|
StringTextOffset = sizeof (EFI_HII_SIBT_STRING_UCS2_BLOCK) - sizeof (CHAR16);
|
|
}
|
|
}
|
|
|
|
LocalFont = NULL;
|
|
GlobalFont = NULL;
|
|
Referred = FALSE;
|
|
|
|
//
|
|
// The input StringFontInfo should exist in current database if specified.
|
|
//
|
|
if (StringFontInfo != NULL) {
|
|
if (!IsFontInfoExisted (Private, StringFontInfo, NULL, NULL, &GlobalFont)) {
|
|
return EFI_INVALID_PARAMETER;
|
|
} else {
|
|
Referred = ReferFontInfoLocally (
|
|
Private,
|
|
StringPackage,
|
|
StringPackage->FontId,
|
|
FALSE,
|
|
GlobalFont,
|
|
&LocalFont
|
|
);
|
|
if (!Referred) {
|
|
StringPackage->FontId++;
|
|
}
|
|
}
|
|
//
|
|
// Update the FontId of the specified string block to input font info.
|
|
//
|
|
switch (BlockType) {
|
|
case EFI_HII_SIBT_STRING_SCSU_FONT:
|
|
case EFI_HII_SIBT_STRINGS_SCSU_FONT:
|
|
case EFI_HII_SIBT_STRING_UCS2_FONT:
|
|
case EFI_HII_SIBT_STRINGS_UCS2_FONT:
|
|
*(StringBlockAddr + sizeof (EFI_HII_STRING_BLOCK)) = LocalFont->FontId;
|
|
break;
|
|
default:
|
|
//
|
|
// When modify the font info of these blocks, the block type should be updated
|
|
// to contain font info thus the whole structure should be revised.
|
|
// It is recommended to use tool to modify the block type not in the code.
|
|
//
|
|
return EFI_UNSUPPORTED;
|
|
}
|
|
}
|
|
|
|
OldBlockSize = StringPackage->StringPkgHdr->Header.Length - StringPackage->StringPkgHdr->HdrSize;
|
|
|
|
//
|
|
// Set the string text and font.
|
|
//
|
|
StringTextPtr = StringBlockAddr + StringTextOffset;
|
|
switch (BlockType) {
|
|
case EFI_HII_SIBT_STRING_SCSU:
|
|
case EFI_HII_SIBT_STRING_SCSU_FONT:
|
|
case EFI_HII_SIBT_STRINGS_SCSU:
|
|
case EFI_HII_SIBT_STRINGS_SCSU_FONT:
|
|
BlockSize = OldBlockSize + StrLen (String);
|
|
BlockSize -= AsciiStrSize ((CHAR8 *) StringTextPtr);
|
|
Block = AllocateZeroPool (BlockSize);
|
|
if (Block == NULL) {
|
|
return EFI_OUT_OF_RESOURCES;
|
|
}
|
|
|
|
CopyMem (Block, StringPackage->StringBlock, StringTextPtr - StringPackage->StringBlock);
|
|
BlockPtr = Block + (StringTextPtr - StringPackage->StringBlock);
|
|
|
|
while (*String != 0) {
|
|
*BlockPtr++ = (CHAR8) *String++;
|
|
}
|
|
*BlockPtr++ = 0;
|
|
|
|
|
|
TmpSize = OldBlockSize - (StringTextPtr - StringPackage->StringBlock) - AsciiStrSize ((CHAR8 *) StringTextPtr);
|
|
CopyMem (
|
|
BlockPtr,
|
|
StringTextPtr + AsciiStrSize ((CHAR8 *)StringTextPtr),
|
|
TmpSize
|
|
);
|
|
|
|
FreePool(StringPackage->StringBlock);
|
|
StringPackage->StringBlock = Block;
|
|
StringPackage->StringPkgHdr->Header.Length += (UINT32) (BlockSize - OldBlockSize);
|
|
break;
|
|
|
|
case EFI_HII_SIBT_STRING_UCS2:
|
|
case EFI_HII_SIBT_STRING_UCS2_FONT:
|
|
case EFI_HII_SIBT_STRINGS_UCS2:
|
|
case EFI_HII_SIBT_STRINGS_UCS2_FONT:
|
|
//
|
|
// Use StrSize to store the size of the specified string, including the NULL
|
|
// terminator.
|
|
//
|
|
GetUnicodeStringTextOrSize (NULL, StringTextPtr, &StringSize);
|
|
|
|
BlockSize = OldBlockSize + StrSize (String) - StringSize;
|
|
Block = AllocateZeroPool (BlockSize);
|
|
if (Block == NULL) {
|
|
return EFI_OUT_OF_RESOURCES;
|
|
}
|
|
|
|
CopyMem (Block, StringPackage->StringBlock, StringTextPtr - StringPackage->StringBlock);
|
|
BlockPtr = Block + (StringTextPtr - StringPackage->StringBlock);
|
|
|
|
CopyMem (BlockPtr, String, StrSize (String));
|
|
BlockPtr += StrSize (String);
|
|
|
|
CopyMem (
|
|
BlockPtr,
|
|
StringTextPtr + StringSize,
|
|
OldBlockSize - (StringTextPtr - StringPackage->StringBlock) - StringSize
|
|
);
|
|
|
|
FreePool(StringPackage->StringBlock);
|
|
StringPackage->StringBlock = Block;
|
|
StringPackage->StringPkgHdr->Header.Length += (UINT32) (BlockSize - OldBlockSize);
|
|
break;
|
|
|
|
default:
|
|
return EFI_NOT_FOUND;
|
|
}
|
|
|
|
//
|
|
// Insert a new EFI_HII_SIBT_FONT_BLOCK to the header of string block, if incoming
|
|
// StringFontInfo does not exist in current string package.
|
|
//
|
|
// This new block does not impact on the value of StringId.
|
|
//
|
|
//
|
|
if (StringFontInfo == NULL || Referred) {
|
|
return EFI_SUCCESS;
|
|
}
|
|
|
|
OldBlockSize = StringPackage->StringPkgHdr->Header.Length - StringPackage->StringPkgHdr->HdrSize;
|
|
BlockSize = OldBlockSize + sizeof (EFI_HII_SIBT_FONT_BLOCK) - sizeof (CHAR16) +
|
|
StrSize (GlobalFont->FontInfo->FontName);
|
|
|
|
Block = AllocateZeroPool (BlockSize);
|
|
if (Block == NULL) {
|
|
return EFI_OUT_OF_RESOURCES;
|
|
}
|
|
|
|
BlockPtr = Block;
|
|
Ext2.Header.BlockType = EFI_HII_SIBT_EXT2;
|
|
Ext2.BlockType2 = EFI_HII_SIBT_FONT;
|
|
Ext2.Length = (UINT16) (BlockSize - OldBlockSize);
|
|
CopyMem (BlockPtr, &Ext2, sizeof (EFI_HII_SIBT_EXT2_BLOCK));
|
|
BlockPtr += sizeof (EFI_HII_SIBT_EXT2_BLOCK);
|
|
|
|
*BlockPtr = LocalFont->FontId;
|
|
BlockPtr ++;
|
|
CopyMem (BlockPtr, &GlobalFont->FontInfo->FontSize, sizeof (UINT16));
|
|
BlockPtr += sizeof (UINT16);
|
|
CopyMem (BlockPtr, &GlobalFont->FontInfo->FontStyle, sizeof (UINT32));
|
|
BlockPtr += sizeof (UINT32);
|
|
CopyMem (
|
|
BlockPtr,
|
|
GlobalFont->FontInfo->FontName,
|
|
StrSize (GlobalFont->FontInfo->FontName)
|
|
);
|
|
BlockPtr += StrSize (GlobalFont->FontInfo->FontName);
|
|
|
|
CopyMem (BlockPtr, StringPackage->StringBlock, OldBlockSize);
|
|
|
|
FreePool(StringPackage->StringBlock);
|
|
StringPackage->StringBlock = Block;
|
|
StringPackage->StringPkgHdr->Header.Length += Ext2.Length;
|
|
|
|
return EFI_SUCCESS;
|
|
|
|
}
|
|
|
|
|
|
/**
|
|
This function adds the string String to the group of strings owned by PackageList, with the
|
|
specified font information StringFontInfo and returns a new string id.
|
|
The new string identifier is guaranteed to be unique within the package list.
|
|
That new string identifier is reserved for all languages in the package list.
|
|
|
|
|
|
@param This A pointer to the EFI_HII_STRING_PROTOCOL instance.
|
|
@param PackageList Handle of the package list where this string will
|
|
be added.
|
|
@param StringId On return, contains the new strings id, which is
|
|
unique within PackageList.
|
|
@param Language Points to the language for the new string.
|
|
@param LanguageName Points to the printable language name to associate
|
|
with the passed in Language field.If LanguageName
|
|
is not NULL and the string package header's
|
|
LanguageName associated with a given Language is
|
|
not zero, the LanguageName being passed in will
|
|
be ignored.
|
|
@param String Points to the new null-terminated string.
|
|
@param StringFontInfo Points to the new string's font information or
|
|
NULL if the string should have the default system
|
|
font, size and style.
|
|
|
|
@retval EFI_SUCCESS The new string was added successfully.
|
|
@retval EFI_NOT_FOUND The specified PackageList could not be found in
|
|
database.
|
|
@retval EFI_OUT_OF_RESOURCES Could not add the string due to lack of resources.
|
|
@retval EFI_INVALID_PARAMETER String is NULL or StringId is NULL or Language is
|
|
NULL.
|
|
@retval EFI_INVALID_PARAMETER The specified StringFontInfo does not exist in
|
|
current database.
|
|
|
|
**/
|
|
EFI_STATUS
|
|
EFIAPI
|
|
HiiNewString (
|
|
IN CONST EFI_HII_STRING_PROTOCOL *This,
|
|
IN EFI_HII_HANDLE PackageList,
|
|
OUT EFI_STRING_ID *StringId,
|
|
IN CONST CHAR8 *Language,
|
|
IN CONST CHAR16 *LanguageName, OPTIONAL
|
|
IN CONST EFI_STRING String,
|
|
IN CONST EFI_FONT_INFO *StringFontInfo OPTIONAL
|
|
)
|
|
{
|
|
EFI_STATUS Status;
|
|
LIST_ENTRY *Link;
|
|
HII_DATABASE_PRIVATE_DATA *Private;
|
|
HII_DATABASE_RECORD *DatabaseRecord;
|
|
HII_DATABASE_PACKAGE_LIST_INSTANCE *PackageListNode;
|
|
HII_STRING_PACKAGE_INSTANCE *StringPackage;
|
|
UINT32 HeaderSize;
|
|
UINT32 BlockSize;
|
|
UINT32 OldBlockSize;
|
|
UINT8 *StringBlock;
|
|
UINT8 *BlockPtr;
|
|
UINT32 Ucs2BlockSize;
|
|
UINT32 FontBlockSize;
|
|
UINT32 Ucs2FontBlockSize;
|
|
EFI_HII_SIBT_EXT2_BLOCK Ext2;
|
|
HII_FONT_INFO *LocalFont;
|
|
HII_GLOBAL_FONT_INFO *GlobalFont;
|
|
EFI_STRING_ID NewStringId;
|
|
EFI_STRING_ID NextStringId;
|
|
EFI_STRING_ID Index;
|
|
HII_STRING_PACKAGE_INSTANCE *MatchStringPackage;
|
|
BOOLEAN NewStringPackageCreated;
|
|
|
|
|
|
if (This == NULL || String == NULL || StringId == NULL || Language == NULL || PackageList == NULL) {
|
|
return EFI_INVALID_PARAMETER;
|
|
}
|
|
|
|
if (!IsHiiHandleValid (PackageList)) {
|
|
return EFI_NOT_FOUND;
|
|
}
|
|
|
|
Private = HII_STRING_DATABASE_PRIVATE_DATA_FROM_THIS (This);
|
|
GlobalFont = NULL;
|
|
|
|
//
|
|
// If StringFontInfo specify a paritcular font, it should exist in current database.
|
|
//
|
|
if (StringFontInfo != NULL) {
|
|
if (!IsFontInfoExisted (Private, (EFI_FONT_INFO *) StringFontInfo, NULL, NULL, &GlobalFont)) {
|
|
return EFI_INVALID_PARAMETER;
|
|
}
|
|
}
|
|
|
|
//
|
|
// Get the matching package list.
|
|
//
|
|
PackageListNode = NULL;
|
|
for (Link = Private->DatabaseList.ForwardLink; Link != &Private->DatabaseList; Link = Link->ForwardLink) {
|
|
DatabaseRecord = CR (Link, HII_DATABASE_RECORD, DatabaseEntry, HII_DATABASE_RECORD_SIGNATURE);
|
|
if (DatabaseRecord->Handle == PackageList) {
|
|
PackageListNode = DatabaseRecord->PackageList;
|
|
break;
|
|
}
|
|
}
|
|
if (PackageListNode == NULL) {
|
|
return EFI_NOT_FOUND;
|
|
}
|
|
|
|
EfiAcquireLock (&mHiiDatabaseLock);
|
|
|
|
Status = EFI_SUCCESS;
|
|
NewStringPackageCreated = FALSE;
|
|
NewStringId = 0;
|
|
NextStringId = 0;
|
|
StringPackage = NULL;
|
|
MatchStringPackage = NULL;
|
|
for (Link = PackageListNode->StringPkgHdr.ForwardLink;
|
|
Link != &PackageListNode->StringPkgHdr;
|
|
Link = Link->ForwardLink
|
|
) {
|
|
StringPackage = CR (Link, HII_STRING_PACKAGE_INSTANCE, StringEntry, HII_STRING_PACKAGE_SIGNATURE);
|
|
//
|
|
// Create a string block and corresponding font block if exists, then append them
|
|
// to the end of the string package.
|
|
//
|
|
Status = FindStringBlock (
|
|
Private,
|
|
StringPackage,
|
|
0,
|
|
NULL,
|
|
NULL,
|
|
NULL,
|
|
&NextStringId,
|
|
NULL
|
|
);
|
|
if (EFI_ERROR(Status)) {
|
|
goto Done;
|
|
}
|
|
//
|
|
// Make sure that new StringId is same in all String Packages for the different language.
|
|
//
|
|
if (NewStringId != 0 && NewStringId != NextStringId) {
|
|
ASSERT (FALSE);
|
|
Status = EFI_INVALID_PARAMETER;
|
|
goto Done;
|
|
}
|
|
NewStringId = NextStringId;
|
|
//
|
|
// Get the matched string package with language.
|
|
//
|
|
if (HiiCompareLanguage (StringPackage->StringPkgHdr->Language, (CHAR8 *) Language)) {
|
|
MatchStringPackage = StringPackage;
|
|
} else {
|
|
OldBlockSize = StringPackage->StringPkgHdr->Header.Length - StringPackage->StringPkgHdr->HdrSize;
|
|
//
|
|
// Create a blank EFI_HII_SIBT_STRING_UCS2_BLOCK to reserve new string ID.
|
|
//
|
|
Ucs2BlockSize = (UINT32) sizeof (EFI_HII_SIBT_STRING_UCS2_BLOCK);
|
|
|
|
StringBlock = (UINT8 *) AllocateZeroPool (OldBlockSize + Ucs2BlockSize);
|
|
if (StringBlock == NULL) {
|
|
Status = EFI_OUT_OF_RESOURCES;
|
|
goto Done;
|
|
}
|
|
//
|
|
// Copy original string blocks, except the EFI_HII_SIBT_END.
|
|
//
|
|
CopyMem (StringBlock, StringPackage->StringBlock, OldBlockSize - sizeof (EFI_HII_SIBT_END_BLOCK));
|
|
//
|
|
// Create a blank EFI_HII_SIBT_STRING_UCS2 block
|
|
//
|
|
BlockPtr = StringBlock + OldBlockSize - sizeof (EFI_HII_SIBT_END_BLOCK);
|
|
*BlockPtr = EFI_HII_SIBT_STRING_UCS2;
|
|
BlockPtr += sizeof (EFI_HII_SIBT_STRING_UCS2_BLOCK);
|
|
|
|
//
|
|
// Append a EFI_HII_SIBT_END block to the end.
|
|
//
|
|
*BlockPtr = EFI_HII_SIBT_END;
|
|
FreePool(StringPackage->StringBlock);
|
|
StringPackage->StringBlock = StringBlock;
|
|
StringPackage->StringPkgHdr->Header.Length += Ucs2BlockSize;
|
|
PackageListNode->PackageListHdr.PackageLength += Ucs2BlockSize;
|
|
}
|
|
}
|
|
if (NewStringId == 0) {
|
|
//
|
|
// No string package is found.
|
|
// Create new string package. StringId 1 is reserved for Language Name string.
|
|
//
|
|
*StringId = 2;
|
|
} else {
|
|
//
|
|
// Set new StringId
|
|
//
|
|
*StringId = (EFI_STRING_ID) (NewStringId + 1);
|
|
}
|
|
|
|
if (MatchStringPackage != NULL) {
|
|
StringPackage = MatchStringPackage;
|
|
} else {
|
|
//
|
|
// LanguageName is required to create a new string package.
|
|
//
|
|
if (LanguageName == NULL) {
|
|
Status = EFI_INVALID_PARAMETER;
|
|
goto Done;
|
|
}
|
|
|
|
StringPackage = AllocateZeroPool (sizeof (HII_STRING_PACKAGE_INSTANCE));
|
|
if (StringPackage == NULL) {
|
|
Status = EFI_OUT_OF_RESOURCES;
|
|
goto Done;
|
|
}
|
|
|
|
StringPackage->Signature = HII_STRING_PACKAGE_SIGNATURE;
|
|
StringPackage->MaxStringId = *StringId;
|
|
StringPackage->FontId = 0;
|
|
InitializeListHead (&StringPackage->FontInfoList);
|
|
|
|
//
|
|
// Fill in the string package header
|
|
//
|
|
HeaderSize = (UINT32) (AsciiStrSize ((CHAR8 *) Language) - 1 + sizeof (EFI_HII_STRING_PACKAGE_HDR));
|
|
StringPackage->StringPkgHdr = AllocateZeroPool (HeaderSize);
|
|
if (StringPackage->StringPkgHdr == NULL) {
|
|
FreePool(StringPackage);
|
|
Status = EFI_OUT_OF_RESOURCES;
|
|
goto Done;
|
|
}
|
|
StringPackage->StringPkgHdr->Header.Type = EFI_HII_PACKAGE_STRINGS;
|
|
StringPackage->StringPkgHdr->HdrSize = HeaderSize;
|
|
StringPackage->StringPkgHdr->StringInfoOffset = HeaderSize;
|
|
CopyMem (StringPackage->StringPkgHdr->LanguageWindow, mLanguageWindow, 16 * sizeof (CHAR16));
|
|
StringPackage->StringPkgHdr->LanguageName = 1;
|
|
AsciiStrCpyS (StringPackage->StringPkgHdr->Language, (HeaderSize - OFFSET_OF(EFI_HII_STRING_PACKAGE_HDR,Language)) / sizeof (CHAR8), (CHAR8 *) Language);
|
|
|
|
//
|
|
// Calculate the length of the string blocks, including string block to record
|
|
// printable language full name and EFI_HII_SIBT_END_BLOCK.
|
|
//
|
|
Ucs2BlockSize = (UINT32) (StrSize ((CHAR16 *) LanguageName) +
|
|
(*StringId - 1) * sizeof (EFI_HII_SIBT_STRING_UCS2_BLOCK) - sizeof (CHAR16));
|
|
|
|
BlockSize = Ucs2BlockSize + sizeof (EFI_HII_SIBT_END_BLOCK);
|
|
StringPackage->StringBlock = (UINT8 *) AllocateZeroPool (BlockSize);
|
|
if (StringPackage->StringBlock == NULL) {
|
|
FreePool(StringPackage->StringPkgHdr);
|
|
FreePool(StringPackage);
|
|
Status = EFI_OUT_OF_RESOURCES;
|
|
goto Done;
|
|
}
|
|
|
|
//
|
|
// Insert the string block of printable language full name
|
|
//
|
|
BlockPtr = StringPackage->StringBlock;
|
|
*BlockPtr = EFI_HII_SIBT_STRING_UCS2;
|
|
BlockPtr += sizeof (EFI_HII_STRING_BLOCK);
|
|
CopyMem (BlockPtr, (EFI_STRING) LanguageName, StrSize ((EFI_STRING) LanguageName));
|
|
BlockPtr += StrSize ((EFI_STRING) LanguageName);
|
|
for (Index = 2; Index <= *StringId - 1; Index ++) {
|
|
*BlockPtr = EFI_HII_SIBT_STRING_UCS2;
|
|
BlockPtr += sizeof (EFI_HII_SIBT_STRING_UCS2_BLOCK);
|
|
}
|
|
//
|
|
// Insert the end block
|
|
//
|
|
*BlockPtr = EFI_HII_SIBT_END;
|
|
|
|
//
|
|
// Append this string package node to string package array in this package list.
|
|
//
|
|
StringPackage->StringPkgHdr->Header.Length = HeaderSize + BlockSize;
|
|
PackageListNode->PackageListHdr.PackageLength += StringPackage->StringPkgHdr->Header.Length;
|
|
InsertTailList (&PackageListNode->StringPkgHdr, &StringPackage->StringEntry);
|
|
NewStringPackageCreated = TRUE;
|
|
}
|
|
|
|
OldBlockSize = StringPackage->StringPkgHdr->Header.Length - StringPackage->StringPkgHdr->HdrSize;
|
|
|
|
if (StringFontInfo == NULL) {
|
|
//
|
|
// Create a EFI_HII_SIBT_STRING_UCS2_BLOCK since font info is not specified.
|
|
//
|
|
Ucs2BlockSize = (UINT32) (StrSize (String) + sizeof (EFI_HII_SIBT_STRING_UCS2_BLOCK)
|
|
- sizeof (CHAR16));
|
|
|
|
StringBlock = (UINT8 *) AllocateZeroPool (OldBlockSize + Ucs2BlockSize);
|
|
if (StringBlock == NULL) {
|
|
Status = EFI_OUT_OF_RESOURCES;
|
|
goto Done;
|
|
}
|
|
//
|
|
// Copy original string blocks, except the EFI_HII_SIBT_END.
|
|
//
|
|
CopyMem (StringBlock, StringPackage->StringBlock, OldBlockSize - sizeof (EFI_HII_SIBT_END_BLOCK));
|
|
//
|
|
// Create a EFI_HII_SIBT_STRING_UCS2 block
|
|
//
|
|
BlockPtr = StringBlock + OldBlockSize - sizeof (EFI_HII_SIBT_END_BLOCK);
|
|
*BlockPtr = EFI_HII_SIBT_STRING_UCS2;
|
|
BlockPtr += sizeof (EFI_HII_STRING_BLOCK);
|
|
CopyMem (BlockPtr, (EFI_STRING) String, StrSize ((EFI_STRING) String));
|
|
BlockPtr += StrSize ((EFI_STRING) String);
|
|
|
|
//
|
|
// Append a EFI_HII_SIBT_END block to the end.
|
|
//
|
|
*BlockPtr = EFI_HII_SIBT_END;
|
|
FreePool(StringPackage->StringBlock);
|
|
StringPackage->StringBlock = StringBlock;
|
|
StringPackage->StringPkgHdr->Header.Length += Ucs2BlockSize;
|
|
PackageListNode->PackageListHdr.PackageLength += Ucs2BlockSize;
|
|
|
|
} else {
|
|
//
|
|
// StringFontInfo is specified here. If there is a EFI_HII_SIBT_FONT_BLOCK
|
|
// which refers to this font info, create a EFI_HII_SIBT_STRING_UCS2_FONT block
|
|
// only. Otherwise create a EFI_HII_SIBT_FONT block with a EFI_HII_SIBT_STRING
|
|
// _UCS2_FONT block.
|
|
//
|
|
Ucs2FontBlockSize = (UINT32) (StrSize (String) + sizeof (EFI_HII_SIBT_STRING_UCS2_FONT_BLOCK) -
|
|
sizeof (CHAR16));
|
|
if (ReferFontInfoLocally (Private, StringPackage, StringPackage->FontId, FALSE, GlobalFont, &LocalFont)) {
|
|
//
|
|
// Create a EFI_HII_SIBT_STRING_UCS2_FONT block only.
|
|
//
|
|
StringBlock = (UINT8 *) AllocateZeroPool (OldBlockSize + Ucs2FontBlockSize);
|
|
if (StringBlock == NULL) {
|
|
Status = EFI_OUT_OF_RESOURCES;
|
|
goto Done;
|
|
}
|
|
//
|
|
// Copy original string blocks, except the EFI_HII_SIBT_END.
|
|
//
|
|
CopyMem (StringBlock, StringPackage->StringBlock, OldBlockSize - sizeof (EFI_HII_SIBT_END_BLOCK));
|
|
//
|
|
// Create a EFI_HII_SIBT_STRING_UCS2_FONT_BLOCK
|
|
//
|
|
BlockPtr = StringBlock + OldBlockSize - sizeof (EFI_HII_SIBT_END_BLOCK);
|
|
*BlockPtr = EFI_HII_SIBT_STRING_UCS2_FONT;
|
|
BlockPtr += sizeof (EFI_HII_STRING_BLOCK);
|
|
*BlockPtr = LocalFont->FontId;
|
|
BlockPtr ++;
|
|
CopyMem (BlockPtr, (EFI_STRING) String, StrSize ((EFI_STRING) String));
|
|
BlockPtr += StrSize ((EFI_STRING) String);
|
|
|
|
//
|
|
// Append a EFI_HII_SIBT_END block to the end.
|
|
//
|
|
*BlockPtr = EFI_HII_SIBT_END;
|
|
FreePool(StringPackage->StringBlock);
|
|
StringPackage->StringBlock = StringBlock;
|
|
StringPackage->StringPkgHdr->Header.Length += Ucs2FontBlockSize;
|
|
PackageListNode->PackageListHdr.PackageLength += Ucs2FontBlockSize;
|
|
|
|
} else {
|
|
//
|
|
// EFI_HII_SIBT_FONT_BLOCK does not exist in current string package, so
|
|
// create a EFI_HII_SIBT_FONT block to record the font info, then generate
|
|
// a EFI_HII_SIBT_STRING_UCS2_FONT block to record the incoming string.
|
|
//
|
|
FontBlockSize = (UINT32) (StrSize (((EFI_FONT_INFO *) StringFontInfo)->FontName) +
|
|
sizeof (EFI_HII_SIBT_FONT_BLOCK) - sizeof (CHAR16));
|
|
StringBlock = (UINT8 *) AllocateZeroPool (OldBlockSize + FontBlockSize + Ucs2FontBlockSize);
|
|
if (StringBlock == NULL) {
|
|
Status = EFI_OUT_OF_RESOURCES;
|
|
goto Done;
|
|
}
|
|
//
|
|
// Copy original string blocks, except the EFI_HII_SIBT_END.
|
|
//
|
|
CopyMem (StringBlock, StringPackage->StringBlock, OldBlockSize - sizeof (EFI_HII_SIBT_END_BLOCK));
|
|
|
|
//
|
|
// Create a EFI_HII_SIBT_FONT block firstly and then backup its info in string
|
|
// package instance for future reference.
|
|
//
|
|
BlockPtr = StringBlock + OldBlockSize - sizeof (EFI_HII_SIBT_END_BLOCK);
|
|
|
|
Ext2.Header.BlockType = EFI_HII_SIBT_EXT2;
|
|
Ext2.BlockType2 = EFI_HII_SIBT_FONT;
|
|
Ext2.Length = (UINT16) FontBlockSize;
|
|
CopyMem (BlockPtr, &Ext2, sizeof (EFI_HII_SIBT_EXT2_BLOCK));
|
|
BlockPtr += sizeof (EFI_HII_SIBT_EXT2_BLOCK);
|
|
|
|
*BlockPtr = LocalFont->FontId;
|
|
BlockPtr ++;
|
|
CopyMem (BlockPtr, &((EFI_FONT_INFO *) StringFontInfo)->FontSize, sizeof (UINT16));
|
|
BlockPtr += sizeof (UINT16);
|
|
CopyMem (BlockPtr, &((EFI_FONT_INFO *) StringFontInfo)->FontStyle, sizeof (EFI_HII_FONT_STYLE));
|
|
BlockPtr += sizeof (EFI_HII_FONT_STYLE);
|
|
CopyMem (
|
|
BlockPtr,
|
|
&((EFI_FONT_INFO *) StringFontInfo)->FontName,
|
|
StrSize (((EFI_FONT_INFO *) StringFontInfo)->FontName)
|
|
);
|
|
BlockPtr += StrSize (((EFI_FONT_INFO *) StringFontInfo)->FontName);
|
|
//
|
|
// Create a EFI_HII_SIBT_STRING_UCS2_FONT_BLOCK
|
|
//
|
|
*BlockPtr = EFI_HII_SIBT_STRING_UCS2_FONT;
|
|
BlockPtr += sizeof (EFI_HII_STRING_BLOCK);
|
|
*BlockPtr = LocalFont->FontId;
|
|
BlockPtr ++;
|
|
CopyMem (BlockPtr, (EFI_STRING) String, StrSize ((EFI_STRING) String));
|
|
BlockPtr += StrSize ((EFI_STRING) String);
|
|
|
|
//
|
|
// Append a EFI_HII_SIBT_END block to the end.
|
|
//
|
|
*BlockPtr = EFI_HII_SIBT_END;
|
|
FreePool(StringPackage->StringBlock);
|
|
StringPackage->StringBlock = StringBlock;
|
|
StringPackage->StringPkgHdr->Header.Length += FontBlockSize + Ucs2FontBlockSize;
|
|
PackageListNode->PackageListHdr.PackageLength += FontBlockSize + Ucs2FontBlockSize;
|
|
|
|
//
|
|
// Increase the FontId to make it unique since we already add
|
|
// a EFI_HII_SIBT_FONT block to this string package.
|
|
//
|
|
StringPackage->FontId++;
|
|
}
|
|
}
|
|
|
|
Done:
|
|
if (!EFI_ERROR(Status) && NewStringPackageCreated) {
|
|
//
|
|
// Trigger any registered notification function for new string package
|
|
//
|
|
Status = InvokeRegisteredFunction (
|
|
Private,
|
|
EFI_HII_DATABASE_NOTIFY_NEW_PACK,
|
|
(VOID *) StringPackage,
|
|
EFI_HII_PACKAGE_STRINGS,
|
|
PackageList
|
|
);
|
|
}
|
|
|
|
if (!EFI_ERROR(Status)) {
|
|
//
|
|
// Update MaxString Id to new StringId
|
|
//
|
|
for (Link = PackageListNode->StringPkgHdr.ForwardLink;
|
|
Link != &PackageListNode->StringPkgHdr;
|
|
Link = Link->ForwardLink
|
|
) {
|
|
StringPackage = CR (Link, HII_STRING_PACKAGE_INSTANCE, StringEntry, HII_STRING_PACKAGE_SIGNATURE);
|
|
StringPackage->MaxStringId = *StringId;
|
|
}
|
|
} else if (NewStringPackageCreated) {
|
|
//
|
|
// Free the allocated new string Package when new string can't be added.
|
|
//
|
|
RemoveEntryList (&StringPackage->StringEntry);
|
|
FreePool(StringPackage->StringBlock);
|
|
FreePool(StringPackage->StringPkgHdr);
|
|
FreePool(StringPackage);
|
|
}
|
|
//
|
|
// The contents of HiiDataBase may updated,need to check.
|
|
//
|
|
//
|
|
// Check whether need to get the contents of HiiDataBase.
|
|
// Only after ReadyToBoot to do the export.
|
|
//
|
|
if (gExportAfterReadyToBoot) {
|
|
if (!EFI_ERROR(Status)) {
|
|
HiiGetDatabaseInfo(&Private->HiiDatabase);
|
|
}
|
|
}
|
|
|
|
EfiReleaseLock (&mHiiDatabaseLock);
|
|
|
|
return Status;
|
|
}
|
|
|
|
|
|
/**
|
|
This function retrieves the string specified by StringId which is associated
|
|
with the specified PackageList in the language Language and copies it into
|
|
the buffer specified by String.
|
|
|
|
@param This A pointer to the EFI_HII_STRING_PROTOCOL instance.
|
|
@param Language Points to the language for the retrieved string.
|
|
@param PackageList The package list in the HII database to search for
|
|
the specified string.
|
|
@param StringId The string's id, which is unique within
|
|
PackageList.
|
|
@param String Points to the new null-terminated string.
|
|
@param StringSize On entry, points to the size of the buffer pointed
|
|
to by String, in bytes. On return, points to the
|
|
length of the string, in bytes.
|
|
@param StringFontInfo If not NULL, points to the string's font
|
|
information. It's caller's responsibility to free
|
|
this buffer.
|
|
|
|
@retval EFI_SUCCESS The string was returned successfully.
|
|
@retval EFI_NOT_FOUND The string specified by StringId is not available.
|
|
@retval EFI_NOT_FOUND The string specified by StringId is available but
|
|
not in the specified language.
|
|
The specified PackageList is not in the database.
|
|
@retval EFI_INVALID_LANGUAGE - The string specified by StringId is available but
|
|
@retval EFI_BUFFER_TOO_SMALL The buffer specified by StringSize is too small to
|
|
hold the string.
|
|
@retval EFI_INVALID_PARAMETER The Language or StringSize was NULL.
|
|
@retval EFI_INVALID_PARAMETER The value referenced by StringSize was not zero and String was NULL.
|
|
@retval EFI_OUT_OF_RESOURCES There were insufficient resources to complete the
|
|
request.
|
|
|
|
**/
|
|
EFI_STATUS
|
|
EFIAPI
|
|
HiiGetString (
|
|
IN CONST EFI_HII_STRING_PROTOCOL *This,
|
|
IN CONST CHAR8 *Language,
|
|
IN EFI_HII_HANDLE PackageList,
|
|
IN EFI_STRING_ID StringId,
|
|
OUT EFI_STRING String,
|
|
IN OUT UINTN *StringSize,
|
|
OUT EFI_FONT_INFO **StringFontInfo OPTIONAL
|
|
)
|
|
{
|
|
EFI_STATUS Status;
|
|
LIST_ENTRY *Link;
|
|
HII_DATABASE_PRIVATE_DATA *Private;
|
|
HII_DATABASE_RECORD *DatabaseRecord;
|
|
HII_DATABASE_PACKAGE_LIST_INSTANCE *PackageListNode;
|
|
HII_STRING_PACKAGE_INSTANCE *StringPackage;
|
|
|
|
if (This == NULL || Language == NULL || StringId < 1 || StringSize == NULL || PackageList == NULL) {
|
|
return EFI_INVALID_PARAMETER;
|
|
}
|
|
|
|
if (String == NULL && *StringSize != 0) {
|
|
return EFI_INVALID_PARAMETER;
|
|
}
|
|
|
|
if (!IsHiiHandleValid (PackageList)) {
|
|
return EFI_NOT_FOUND;
|
|
}
|
|
|
|
Private = HII_STRING_DATABASE_PRIVATE_DATA_FROM_THIS (This);
|
|
PackageListNode = NULL;
|
|
|
|
for (Link = Private->DatabaseList.ForwardLink; Link != &Private->DatabaseList; Link = Link->ForwardLink) {
|
|
DatabaseRecord = CR (Link, HII_DATABASE_RECORD, DatabaseEntry, HII_DATABASE_RECORD_SIGNATURE);
|
|
if (DatabaseRecord->Handle == PackageList) {
|
|
PackageListNode = DatabaseRecord->PackageList;
|
|
break;
|
|
}
|
|
}
|
|
|
|
if (PackageListNode != NULL) {
|
|
//
|
|
// First search: to match the StringId in the specified language.
|
|
//
|
|
for (Link = PackageListNode->StringPkgHdr.ForwardLink;
|
|
Link != &PackageListNode->StringPkgHdr;
|
|
Link = Link->ForwardLink
|
|
) {
|
|
StringPackage = CR (Link, HII_STRING_PACKAGE_INSTANCE, StringEntry, HII_STRING_PACKAGE_SIGNATURE);
|
|
if (HiiCompareLanguage (StringPackage->StringPkgHdr->Language, (CHAR8 *) Language)) {
|
|
Status = GetStringWorker (Private, StringPackage, StringId, String, StringSize, StringFontInfo);
|
|
if (Status != EFI_NOT_FOUND) {
|
|
return Status;
|
|
}
|
|
}
|
|
}
|
|
//
|
|
// Second search: to match the StringId in other available languages if exist.
|
|
//
|
|
for (Link = PackageListNode->StringPkgHdr.ForwardLink;
|
|
Link != &PackageListNode->StringPkgHdr;
|
|
Link = Link->ForwardLink
|
|
) {
|
|
StringPackage = CR (Link, HII_STRING_PACKAGE_INSTANCE, StringEntry, HII_STRING_PACKAGE_SIGNATURE);
|
|
Status = GetStringWorker (Private, StringPackage, StringId, NULL, NULL, NULL);
|
|
if (!EFI_ERROR(Status)) {
|
|
return EFI_INVALID_LANGUAGE;
|
|
}
|
|
}
|
|
}
|
|
|
|
return EFI_NOT_FOUND;
|
|
}
|
|
|
|
|
|
|
|
/**
|
|
This function updates the string specified by StringId in the specified PackageList to the text
|
|
specified by String and, optionally, the font information specified by StringFontInfo.
|
|
|
|
@param This A pointer to the EFI_HII_STRING_PROTOCOL instance.
|
|
@param PackageList The package list containing the strings.
|
|
@param StringId The string's id, which is unique within
|
|
PackageList.
|
|
@param Language Points to the language for the updated string.
|
|
@param String Points to the new null-terminated string.
|
|
@param StringFontInfo Points to the string's font information or NULL if
|
|
the string font information is not changed.
|
|
|
|
@retval EFI_SUCCESS The string was updated successfully.
|
|
@retval EFI_NOT_FOUND The string specified by StringId is not in the
|
|
database.
|
|
@retval EFI_INVALID_PARAMETER The String or Language was NULL.
|
|
@retval EFI_INVALID_PARAMETER The specified StringFontInfo does not exist in
|
|
current database.
|
|
@retval EFI_OUT_OF_RESOURCES The system is out of resources to accomplish the
|
|
task.
|
|
|
|
**/
|
|
EFI_STATUS
|
|
EFIAPI
|
|
HiiSetString (
|
|
IN CONST EFI_HII_STRING_PROTOCOL *This,
|
|
IN EFI_HII_HANDLE PackageList,
|
|
IN EFI_STRING_ID StringId,
|
|
IN CONST CHAR8 *Language,
|
|
IN CONST EFI_STRING String,
|
|
IN CONST EFI_FONT_INFO *StringFontInfo OPTIONAL
|
|
)
|
|
{
|
|
EFI_STATUS Status;
|
|
LIST_ENTRY *Link;
|
|
HII_DATABASE_PRIVATE_DATA *Private;
|
|
HII_DATABASE_RECORD *DatabaseRecord;
|
|
HII_DATABASE_PACKAGE_LIST_INSTANCE *PackageListNode;
|
|
HII_STRING_PACKAGE_INSTANCE *StringPackage;
|
|
UINT32 OldPackageLen;
|
|
|
|
if (This == NULL || Language == NULL || StringId < 1 || String == NULL || PackageList == NULL) {
|
|
return EFI_INVALID_PARAMETER;
|
|
}
|
|
|
|
if (!IsHiiHandleValid (PackageList)) {
|
|
return EFI_NOT_FOUND;
|
|
}
|
|
|
|
EfiAcquireLock (&mHiiDatabaseLock);
|
|
|
|
Private = HII_STRING_DATABASE_PRIVATE_DATA_FROM_THIS (This);
|
|
PackageListNode = NULL;
|
|
|
|
for (Link = Private->DatabaseList.ForwardLink; Link != &Private->DatabaseList; Link = Link->ForwardLink) {
|
|
DatabaseRecord = CR (Link, HII_DATABASE_RECORD, DatabaseEntry, HII_DATABASE_RECORD_SIGNATURE);
|
|
if (DatabaseRecord->Handle == PackageList) {
|
|
PackageListNode = (HII_DATABASE_PACKAGE_LIST_INSTANCE *) (DatabaseRecord->PackageList);
|
|
}
|
|
}
|
|
|
|
if (PackageListNode != NULL) {
|
|
for (Link = PackageListNode->StringPkgHdr.ForwardLink;
|
|
Link != &PackageListNode->StringPkgHdr;
|
|
Link = Link->ForwardLink
|
|
) {
|
|
StringPackage = CR (Link, HII_STRING_PACKAGE_INSTANCE, StringEntry, HII_STRING_PACKAGE_SIGNATURE);
|
|
if (HiiCompareLanguage (StringPackage->StringPkgHdr->Language, (CHAR8 *) Language)) {
|
|
OldPackageLen = StringPackage->StringPkgHdr->Header.Length;
|
|
Status = SetStringWorker (
|
|
Private,
|
|
StringPackage,
|
|
StringId,
|
|
(EFI_STRING) String,
|
|
(EFI_FONT_INFO *) StringFontInfo
|
|
);
|
|
if (EFI_ERROR(Status)) {
|
|
EfiReleaseLock (&mHiiDatabaseLock);
|
|
return Status;
|
|
}
|
|
PackageListNode->PackageListHdr.PackageLength += StringPackage->StringPkgHdr->Header.Length - OldPackageLen;
|
|
//
|
|
// Check whether need to get the contents of HiiDataBase.
|
|
// Only after ReadyToBoot to do the export.
|
|
//
|
|
if (gExportAfterReadyToBoot) {
|
|
HiiGetDatabaseInfo(&Private->HiiDatabase);
|
|
}
|
|
EfiReleaseLock (&mHiiDatabaseLock);
|
|
return EFI_SUCCESS;
|
|
}
|
|
}
|
|
}
|
|
|
|
EfiReleaseLock (&mHiiDatabaseLock);
|
|
return EFI_NOT_FOUND;
|
|
}
|
|
|
|
|
|
|
|
/**
|
|
This function returns the list of supported languages, in the format specified
|
|
in Appendix M of UEFI 2.1 spec.
|
|
|
|
@param This A pointer to the EFI_HII_STRING_PROTOCOL instance.
|
|
@param PackageList The package list to examine.
|
|
@param Languages Points to the buffer to hold the returned
|
|
null-terminated ASCII string.
|
|
@param LanguagesSize On entry, points to the size of the buffer pointed
|
|
to by Languages, in bytes. On return, points to
|
|
the length of Languages, in bytes.
|
|
|
|
@retval EFI_SUCCESS The languages were returned successfully.
|
|
@retval EFI_INVALID_PARAMETER The LanguagesSize was NULL.
|
|
@retval EFI_INVALID_PARAMETER The value referenced by LanguagesSize is not zero and Languages is NULL.
|
|
@retval EFI_BUFFER_TOO_SMALL The LanguagesSize is too small to hold the list of
|
|
supported languages. LanguageSize is updated to
|
|
contain the required size.
|
|
@retval EFI_NOT_FOUND Could not find string package in specified
|
|
packagelist.
|
|
|
|
**/
|
|
EFI_STATUS
|
|
EFIAPI
|
|
HiiGetLanguages (
|
|
IN CONST EFI_HII_STRING_PROTOCOL *This,
|
|
IN EFI_HII_HANDLE PackageList,
|
|
IN OUT CHAR8 *Languages,
|
|
IN OUT UINTN *LanguagesSize
|
|
)
|
|
{
|
|
LIST_ENTRY *Link;
|
|
HII_DATABASE_PRIVATE_DATA *Private;
|
|
HII_DATABASE_RECORD *DatabaseRecord;
|
|
HII_DATABASE_PACKAGE_LIST_INSTANCE *PackageListNode;
|
|
HII_STRING_PACKAGE_INSTANCE *StringPackage;
|
|
UINTN ResultSize;
|
|
|
|
if (This == NULL || LanguagesSize == NULL || PackageList == NULL) {
|
|
return EFI_INVALID_PARAMETER;
|
|
}
|
|
if (*LanguagesSize != 0 && Languages == NULL) {
|
|
return EFI_INVALID_PARAMETER;
|
|
}
|
|
if (!IsHiiHandleValid (PackageList)) {
|
|
return EFI_NOT_FOUND;
|
|
}
|
|
|
|
Private = HII_STRING_DATABASE_PRIVATE_DATA_FROM_THIS (This);
|
|
|
|
PackageListNode = NULL;
|
|
for (Link = Private->DatabaseList.ForwardLink; Link != &Private->DatabaseList; Link = Link->ForwardLink) {
|
|
DatabaseRecord = CR (Link, HII_DATABASE_RECORD, DatabaseEntry, HII_DATABASE_RECORD_SIGNATURE);
|
|
if (DatabaseRecord->Handle == PackageList) {
|
|
PackageListNode = DatabaseRecord->PackageList;
|
|
break;
|
|
}
|
|
}
|
|
if (PackageListNode == NULL) {
|
|
return EFI_NOT_FOUND;
|
|
}
|
|
|
|
//
|
|
// Search the languages in the specified packagelist.
|
|
//
|
|
ResultSize = 0;
|
|
for (Link = PackageListNode->StringPkgHdr.ForwardLink;
|
|
Link != &PackageListNode->StringPkgHdr;
|
|
Link = Link->ForwardLink
|
|
) {
|
|
StringPackage = CR (Link, HII_STRING_PACKAGE_INSTANCE, StringEntry, HII_STRING_PACKAGE_SIGNATURE);
|
|
ResultSize += AsciiStrSize (StringPackage->StringPkgHdr->Language);
|
|
if (ResultSize <= *LanguagesSize) {
|
|
AsciiStrCpyS (Languages, *LanguagesSize / sizeof (CHAR8), StringPackage->StringPkgHdr->Language);
|
|
Languages += AsciiStrSize (StringPackage->StringPkgHdr->Language);
|
|
*(Languages - 1) = L';';
|
|
}
|
|
}
|
|
if (ResultSize == 0) {
|
|
return EFI_NOT_FOUND;
|
|
}
|
|
|
|
if (*LanguagesSize < ResultSize) {
|
|
*LanguagesSize = ResultSize;
|
|
return EFI_BUFFER_TOO_SMALL;
|
|
}
|
|
|
|
*(Languages - 1) = 0;
|
|
return EFI_SUCCESS;
|
|
}
|
|
|
|
|
|
/**
|
|
Each string package has associated with it a single primary language and zero
|
|
or more secondary languages. This routine returns the secondary languages
|
|
associated with a package list.
|
|
|
|
@param This A pointer to the EFI_HII_STRING_PROTOCOL instance.
|
|
@param PackageList The package list to examine.
|
|
@param PrimaryLanguage Points to the null-terminated ASCII string that specifies
|
|
the primary language. Languages are specified in the
|
|
format specified in Appendix M of the UEFI 2.0 specification.
|
|
@param SecondaryLanguages Points to the buffer to hold the returned null-terminated
|
|
ASCII string that describes the list of
|
|
secondary languages for the specified
|
|
PrimaryLanguage. If there are no secondary
|
|
languages, the function returns successfully, but
|
|
this is set to NULL.
|
|
@param SecondaryLanguagesSize On entry, points to the size of the buffer pointed
|
|
to by SecondaryLanguages, in bytes. On return,
|
|
points to the length of SecondaryLanguages in bytes.
|
|
|
|
@retval EFI_SUCCESS Secondary languages were correctly returned.
|
|
@retval EFI_INVALID_PARAMETER PrimaryLanguage or SecondaryLanguagesSize was NULL.
|
|
@retval EFI_INVALID_PARAMETER The value referenced by SecondaryLanguagesSize is not
|
|
zero and SecondaryLanguages is NULL.
|
|
@retval EFI_BUFFER_TOO_SMALL The buffer specified by SecondaryLanguagesSize is
|
|
too small to hold the returned information.
|
|
SecondaryLanguageSize is updated to hold the size of
|
|
the buffer required.
|
|
@retval EFI_INVALID_LANGUAGE The language specified by PrimaryLanguage is not
|
|
present in the specified package list.
|
|
@retval EFI_NOT_FOUND The specified PackageList is not in the Database.
|
|
|
|
**/
|
|
EFI_STATUS
|
|
EFIAPI
|
|
HiiGetSecondaryLanguages (
|
|
IN CONST EFI_HII_STRING_PROTOCOL *This,
|
|
IN EFI_HII_HANDLE PackageList,
|
|
IN CONST CHAR8 *PrimaryLanguage,
|
|
IN OUT CHAR8 *SecondaryLanguages,
|
|
IN OUT UINTN *SecondaryLanguagesSize
|
|
)
|
|
{
|
|
LIST_ENTRY *Link;
|
|
LIST_ENTRY *Link1;
|
|
HII_DATABASE_PRIVATE_DATA *Private;
|
|
HII_DATABASE_RECORD *DatabaseRecord;
|
|
HII_DATABASE_PACKAGE_LIST_INSTANCE *PackageListNode;
|
|
HII_STRING_PACKAGE_INSTANCE *StringPackage;
|
|
CHAR8 *Languages;
|
|
UINTN ResultSize;
|
|
|
|
if (This == NULL || PackageList == NULL || PrimaryLanguage == NULL || SecondaryLanguagesSize == NULL) {
|
|
return EFI_INVALID_PARAMETER;
|
|
}
|
|
if (SecondaryLanguages == NULL && *SecondaryLanguagesSize != 0) {
|
|
return EFI_INVALID_PARAMETER;
|
|
}
|
|
if (!IsHiiHandleValid (PackageList)) {
|
|
return EFI_NOT_FOUND;
|
|
}
|
|
|
|
Private = HII_STRING_DATABASE_PRIVATE_DATA_FROM_THIS (This);
|
|
|
|
PackageListNode = NULL;
|
|
for (Link = Private->DatabaseList.ForwardLink; Link != &Private->DatabaseList; Link = Link->ForwardLink) {
|
|
DatabaseRecord = CR (Link, HII_DATABASE_RECORD, DatabaseEntry, HII_DATABASE_RECORD_SIGNATURE);
|
|
if (DatabaseRecord->Handle == PackageList) {
|
|
PackageListNode = (HII_DATABASE_PACKAGE_LIST_INSTANCE *) (DatabaseRecord->PackageList);
|
|
break;
|
|
}
|
|
}
|
|
if (PackageListNode == NULL) {
|
|
return EFI_NOT_FOUND;
|
|
}
|
|
|
|
Languages = NULL;
|
|
ResultSize = 0;
|
|
for (Link1 = PackageListNode->StringPkgHdr.ForwardLink;
|
|
Link1 != &PackageListNode->StringPkgHdr;
|
|
Link1 = Link1->ForwardLink
|
|
) {
|
|
StringPackage = CR (Link1, HII_STRING_PACKAGE_INSTANCE, StringEntry, HII_STRING_PACKAGE_SIGNATURE);
|
|
if (HiiCompareLanguage (StringPackage->StringPkgHdr->Language, (CHAR8 *) PrimaryLanguage)) {
|
|
Languages = StringPackage->StringPkgHdr->Language;
|
|
//
|
|
// Language is a series of ';' terminated strings, first one is primary
|
|
// language and following with other secondary languages or NULL if no
|
|
// secondary languages any more.
|
|
//
|
|
Languages = AsciiStrStr (Languages, ";");
|
|
if (Languages == NULL) {
|
|
break;
|
|
}
|
|
Languages++;
|
|
|
|
ResultSize = AsciiStrSize (Languages);
|
|
if (ResultSize <= *SecondaryLanguagesSize) {
|
|
AsciiStrCpyS (SecondaryLanguages, *SecondaryLanguagesSize / sizeof (CHAR8), Languages);
|
|
} else {
|
|
*SecondaryLanguagesSize = ResultSize;
|
|
return EFI_BUFFER_TOO_SMALL;
|
|
}
|
|
|
|
return EFI_SUCCESS;
|
|
}
|
|
}
|
|
|
|
return EFI_INVALID_LANGUAGE;
|
|
}
|
|
|
|
/**
|
|
Converts the ascii character of the string from uppercase to lowercase.
|
|
This is a internal function.
|
|
|
|
@param ConfigString String to be converted
|
|
|
|
**/
|
|
VOID
|
|
EFIAPI
|
|
AsciiHiiToLower (
|
|
IN CHAR8 *ConfigString
|
|
)
|
|
{
|
|
ASSERT (ConfigString != NULL);
|
|
|
|
//
|
|
// Convert all hex digits in range [A-F] in the configuration header to [a-f]
|
|
//
|
|
for (; *ConfigString != '\0'; ConfigString++) {
|
|
if ( *ConfigString >= 'A' && *ConfigString <= 'Z') {
|
|
*ConfigString = (CHAR8) (*ConfigString - 'A' + 'a');
|
|
}
|
|
}
|
|
}
|
|
|
|
/**
|
|
Compare whether two names of languages are identical.
|
|
|
|
@param Language1 Name of language 1 from StringPackage
|
|
@param Language2 Name of language 2 to be compared with language 1.
|
|
|
|
@retval TRUE same
|
|
@retval FALSE not same
|
|
|
|
**/
|
|
BOOLEAN
|
|
HiiCompareLanguage (
|
|
IN CHAR8 *Language1,
|
|
IN CHAR8 *Language2
|
|
)
|
|
{
|
|
UINTN Index;
|
|
UINTN StrLen;
|
|
CHAR8 *Lan1;
|
|
CHAR8 *Lan2;
|
|
|
|
//
|
|
// Convert to lower to compare.
|
|
//
|
|
StrLen = AsciiStrSize (Language1);
|
|
Lan1 = AllocateZeroPool (StrLen);
|
|
ASSERT (Lan1 != NULL);
|
|
AsciiStrCpyS(Lan1, StrLen / sizeof (CHAR8), Language1);
|
|
AsciiHiiToLower (Lan1);
|
|
|
|
StrLen = AsciiStrSize (Language2);
|
|
Lan2 = AllocateZeroPool (StrLen);
|
|
ASSERT (Lan2 != NULL);
|
|
AsciiStrCpyS(Lan2, StrLen / sizeof (CHAR8), Language2);
|
|
AsciiHiiToLower (Lan2);
|
|
|
|
//
|
|
// Compare the Primary Language in Language1 to Language2
|
|
//
|
|
for (Index = 0; Lan1[Index] != 0 && Lan1[Index] != ';'; Index++) {
|
|
if (Lan1[Index] != Lan2[Index]) {
|
|
//
|
|
// Return FALSE if any characters are different.
|
|
//
|
|
FreePool(Lan1);
|
|
FreePool(Lan2);
|
|
return FALSE;
|
|
}
|
|
}
|
|
|
|
FreePool(Lan1);
|
|
FreePool(Lan2);
|
|
|
|
//
|
|
// Only return TRUE if Language2[Index] is a Null-terminator which means
|
|
// the Primary Language in Language1 is the same length as Language2. If
|
|
// Language2[Index] is not a Null-terminator, then Language2 is longer than
|
|
// the Primary Language in Language1, and FALSE must be returned.
|
|
//
|
|
return (BOOLEAN) (Language2[Index] == 0);
|
|
}
|