Upstream/CloverBootloader
1
0
Fork 0
mirror of https://github.com/CloverHackyColor/CloverBootloader.git synced 2024-11-24 11:45:27 +01:00
Code Issues Packages Projects Releases Wiki Activity
19cfe2831a
CloverBootloader/MdeModulePkg/Universal/HiiDatabaseDxe/String.c
Sergey Isakov 7c0aa811ec initial commit Clover sources 5061 and modules from EDK2 latest with legacy codes from UDK2018 
Signed-off-by: Sergey Isakov <isakov-sl@bk.ru>
2019-09-03 12:58:42 +03:00

2079 lines
76 KiB
C
Raw Blame History

/** @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);
}
Reference in New Issue View Git Blame Copy Permalink