VOID
EfiStrnCpy (
OUT CHAR16 *Dst,
IN CHAR16 *Src,
IN UINTN Length
)
/*++
Routine Description:
Copy a string from source to destination
Arguments:
Dst Destination string
Src Source string
Length Length of destination string
Returns:
--*/
{
UINTN Index;
UINTN SrcLen;
SrcLen = EfiStrLen (Src);
Index = 0;
while (Index < Length && Index < SrcLen) {
Dst[Index] = Src[Index];
Index++;
}
for (Index = SrcLen; Index < Length; Index++) {
Dst[Index] = 0;
}
}
CHAR16 *
StslStrDuplicate (
IN CHAR16 *String
)
{
EFI_STATUS Status;
CHAR16 *Buffer;
if (String == NULL) {
return NULL;
}
Status = gBS->AllocatePool (
EfiBootServicesData,
(EfiStrLen (String) + 1) * sizeof(CHAR16),
&Buffer
);
if (EFI_ERROR (Status)) {
return NULL;
}
EfiStrCpy (Buffer, String);
return Buffer;
}
EFI_STATUS
EFIAPI
TrlSetConfig (
IN EFI_TRL_PRIVATE_INTERFACE *This,
EFI_DEVICE_PATH_PROTOCOL *DevicePath,
CHAR16 *FileName
)
/*++
Routine Description:
One private interface function of the TestRecoveryLibrary to set config.
Arguments:
This - the private interface instance structure.
DevicePath - device path of the reset record file.
FileName - filename of the reset record file.
Returns:
EFI_SUCCESS - set config successfully.
EFI_OUT_OF_RESOURCES - not enough memory.
EFI_INVALID_PARAMETER - invalid parameters.
--*/
{
EFI_STATUS Status;
TEST_RECOVERY_PRIVATE_DATA *Private;
Private = TEST_RECOVERY_PRIVATE_DATA_FROM_PI (This);
TrlFreePointer (Private);
if ((DevicePath == NULL) || (FileName == NULL)) {
return EFI_INVALID_PARAMETER;
}
//
// DevicePath & FileName
//
Private->DevicePath = EfiDuplicateDevicePath (DevicePath);
if (Private->DevicePath == NULL) {
TrlFreePointer (Private);
return EFI_OUT_OF_RESOURCES;
}
Status = gBS->AllocatePool (
EfiBootServicesData,
(EfiStrLen (FileName) + 1) * 2,
&(Private->FileName)
);
if (EFI_ERROR (Status)) {
TrlFreePointer (Private);
return Status;
}
EfiStrCpy (Private->FileName, FileName);
return EFI_SUCCESS;
}
EFI_STATUS
EFIAPI
StslRecordMessage (
IN EFI_STANDARD_TEST_LIBRARY_PROTOCOL *This,
IN EFI_VERBOSE_LEVEL VerboseLevel,
IN CHAR16 *Message,
...
)
/*++
Routine Description:
Records the test message.
Arguments:
This - Standard test library protocol instance.
VerboseLevel - Minimal verbose level to record this message. For example,
EFI_VERBOSE_LEVEL_QUIET means this message should be recorded
even the test is run in QUIET mode. On the contrary,
EFI_VERBOSE_LEVEL_EXHAUSTIVE means this message will only be
recorded when the test is run in EXHAUSTIVE mode.
Message - Format string for the detail test information.
Returns:
EFI_SUCCESS - record the message successfully.
--*/
{
EFI_STATUS Status;
VA_LIST Marker;
CHAR16 Buffer[EFI_MAX_PRINT_BUFFER];
STANDARD_TEST_PRIVATE_DATA *Private;
Status = EFI_SUCCESS;
Private = STANDARD_TEST_PRIVATE_DATA_FROM_STSL (This);
if (VerboseLevel <= Private->VerboseLevel) {
VA_START(Marker, Message);
VSPrint (Buffer, EFI_MAX_PRINT_BUFFER, Message, Marker);
VA_END (Marker);
if ( EfiStrLen (Buffer) + 3 < EFI_MAX_PRINT_BUFFER ) {
EfiStrCat (Buffer, L"\r\n");
}
Status = StslWriteLogFile (Private, Buffer);
}
return Status;
}
UINTN
EfiStrSize (
IN CHAR16 *String
)
/*++
Routine Description:
Return the number bytes in the Unicode String. This is not the same as
the length of the string in characters. The string size includes the NULL
Arguments:
String - String to process
Returns:
Number of bytes in String
--*/
{
return ((EfiStrLen (String) + 1) * sizeof (CHAR16));
}
VOID
EfiStrCat (
IN CHAR16 *Destination,
IN CHAR16 *Source
)
/*++
Routine Description:
Concatinate Source on the end of Destination
Arguments:
Destination - String to added to the end of.
Source - String to concatinate.
Returns:
NONE
--*/
{
EfiStrCpy (Destination + EfiStrLen (Destination), Source);
}
VOID
EfiStrnCat (
IN CHAR16 *Dest,
IN CHAR16 *Src,
IN UINTN Length
)
/*++
Routine Description:
Concatinate Source on the end of Destination
Arguments:
Dst Destination string
Src Source string
Length Length of destination string
Returns:
--*/
{
EfiStrnCpy (Dest + EfiStrLen (Dest), Src, Length);
}
EFI_STATUS
GetSelectionInputPopUp (
IN UI_MENU_SELECTION *Selection,
IN UI_MENU_OPTION *MenuOption
)
/*++
Routine Description:
Get selection for OneOf and OrderedList (Left/Right will be ignored).
Arguments:
Selection - Pointer to current selection.
MenuOption - Pointer to the current input menu.
Returns:
EFI_SUCCESS - If Option input is processed successfully
EFI_DEVICE_ERROR - If operation fails
--*/
{
EFI_STATUS Status;
EFI_INPUT_KEY Key;
UINTN Index;
CHAR16 *StringPtr;
CHAR16 *TempStringPtr;
UINTN Index2;
UINTN TopOptionIndex;
UINTN HighlightOptionIndex;
UINTN Start;
UINTN End;
UINTN Top;
UINTN Bottom;
UINTN PopUpMenuLines;
UINTN MenuLinesInView;
UINTN PopUpWidth;
CHAR16 Character;
INT32 SavedAttribute;
BOOLEAN ShowDownArrow;
BOOLEAN ShowUpArrow;
UINTN DimensionsWidth;
UINTN DimensionsHeight;
EFI_LIST_ENTRY *Link;
BOOLEAN OrderedList;
UINT8 *ValueArray;
UINT8 ValueType;
EFI_HII_VALUE HiiValue;
EFI_HII_VALUE *HiiValueArray;
UINTN OptionCount;
QUESTION_OPTION *OneOfOption;
QUESTION_OPTION *CurrentOption;
FORM_BROWSER_STATEMENT *Question;
DimensionsWidth = gScreenDimensions.RightColumn - gScreenDimensions.LeftColumn;
DimensionsHeight = gScreenDimensions.BottomRow - gScreenDimensions.TopRow;
ValueArray = NULL;
ValueType = 0;
CurrentOption = NULL;
ShowDownArrow = FALSE;
ShowUpArrow = FALSE;
StringPtr = EfiLibAllocateZeroPool ((gOptionBlockWidth + 1) * 2);
ASSERT (StringPtr);
Question = MenuOption->ThisTag;
if (Question->Operand == EFI_IFR_ORDERED_LIST_OP) {
ValueArray = Question->BufferValue;
ValueType = Question->ValueType;
OrderedList = TRUE;
} else {
OrderedList = FALSE;
}
//
// Calculate Option count
//
if (OrderedList) {
for (Index = 0; Index < Question->MaxContainers; Index++) {
if (GetArrayData (ValueArray, ValueType, Index) == 0) {
break;
}
}
OptionCount = Index;
} else {
OptionCount = 0;
Link = GetFirstNode (&Question->OptionListHead);
while (!IsNull (&Question->OptionListHead, Link)) {
OneOfOption = QUESTION_OPTION_FROM_LINK (Link);
OptionCount++;
Link = GetNextNode (&Question->OptionListHead, Link);
}
}
//
// Prepare HiiValue array
//
HiiValueArray = EfiLibAllocateZeroPool (OptionCount * sizeof (EFI_HII_VALUE));
ASSERT (HiiValueArray != NULL);
Link = GetFirstNode (&Question->OptionListHead);
for (Index = 0; Index < OptionCount; Index++) {
if (OrderedList) {
HiiValueArray[Index].Type = ValueType;
HiiValueArray[Index].Value.u64 = GetArrayData (ValueArray, ValueType, Index);
} else {
OneOfOption = QUESTION_OPTION_FROM_LINK (Link);
EfiCopyMem (&HiiValueArray[Index], &OneOfOption->Value, sizeof (EFI_HII_VALUE));
Link = GetNextNode (&Question->OptionListHead, Link);
}
}
//
// Move Suppressed Option to list tail
//
PopUpMenuLines = 0;
for (Index = 0; Index < OptionCount; Index++) {
OneOfOption = ValueToOption (Question, &HiiValueArray[OptionCount - Index - 1]);
if (OneOfOption == NULL) {
return EFI_NOT_FOUND;
}
RemoveEntryList (&OneOfOption->Link);
if ((OneOfOption->SuppressExpression != NULL) &&
(OneOfOption->SuppressExpression->Result.Value.b)) {
//
// This option is suppressed, insert to tail
//
InsertTailList (&Question->OptionListHead, &OneOfOption->Link);
} else {
//
// Insert to head
//
InsertHeadList (&Question->OptionListHead, &OneOfOption->Link);
PopUpMenuLines++;
}
}
//
// Get the number of one of options present and its size
//
PopUpWidth = 0;
HighlightOptionIndex = 0;
Link = GetFirstNode (&Question->OptionListHead);
for (Index = 0; Index < PopUpMenuLines; Index++) {
OneOfOption = QUESTION_OPTION_FROM_LINK (Link);
StringPtr = GetToken (OneOfOption->Text, MenuOption->Handle);
if (EfiStrLen (StringPtr) > PopUpWidth) {
PopUpWidth = EfiStrLen (StringPtr);
}
gBS->FreePool (StringPtr);
if (!OrderedList && CompareHiiValue (&Question->HiiValue, &OneOfOption->Value, NULL) == 0) {
//
// Find current selected Option for OneOf
//
HighlightOptionIndex = Index;
}
Link = GetNextNode (&Question->OptionListHead, Link);
}
//
// Perform popup menu initialization.
//
PopUpWidth = PopUpWidth + POPUP_PAD_SPACE_COUNT;
SavedAttribute = gST->ConOut->Mode->Attribute;
gST->ConOut->SetAttribute (gST->ConOut, POPUP_TEXT | POPUP_BACKGROUND);
if ((PopUpWidth + POPUP_FRAME_WIDTH) > DimensionsWidth) {
PopUpWidth = DimensionsWidth - POPUP_FRAME_WIDTH;
}
Start = (DimensionsWidth - PopUpWidth - POPUP_FRAME_WIDTH) / 2 + gScreenDimensions.LeftColumn;
End = Start + PopUpWidth + POPUP_FRAME_WIDTH;
Top = gScreenDimensions.TopRow + NONE_FRONT_PAGE_HEADER_HEIGHT;
Bottom = gScreenDimensions.BottomRow - STATUS_BAR_HEIGHT - FOOTER_HEIGHT - 1;
MenuLinesInView = Bottom - Top - 1;
if (MenuLinesInView >= PopUpMenuLines) {
Top = Top + (MenuLinesInView - PopUpMenuLines) / 2;
Bottom = Top + PopUpMenuLines + 1;
} else {
ShowDownArrow = TRUE;
}
if (HighlightOptionIndex > (MenuLinesInView - 1)) {
TopOptionIndex = HighlightOptionIndex - MenuLinesInView + 1;
} else {
TopOptionIndex = 0;
}
do {
//
// Clear that portion of the screen
//
ClearLines (Start, End, Top, Bottom, POPUP_TEXT | POPUP_BACKGROUND);
//
// Draw "One of" pop-up menu
//
Character = BOXDRAW_DOWN_RIGHT;
PrintCharAt (Start, Top, Character);
for (Index = Start; Index + 2 < End; Index++) {
if ((ShowUpArrow) && ((Index + 1) == (Start + End) / 2)) {
Character = GEOMETRICSHAPE_UP_TRIANGLE;
} else {
Character = BOXDRAW_HORIZONTAL;
}
PrintChar (Character);
}
Character = BOXDRAW_DOWN_LEFT;
PrintChar (Character);
Character = BOXDRAW_VERTICAL;
for (Index = Top + 1; Index < Bottom; Index++) {
PrintCharAt (Start, Index, Character);
PrintCharAt (End - 1, Index, Character);
}
//
// Move to top Option
//
Link = GetFirstNode (&Question->OptionListHead);
for (Index = 0; Index < TopOptionIndex; Index++) {
Link = GetNextNode (&Question->OptionListHead, Link);
}
//
// Display the One of options
//
Index2 = Top + 1;
for (Index = TopOptionIndex; (Index < PopUpMenuLines) && (Index2 < Bottom); Index++) {
OneOfOption = QUESTION_OPTION_FROM_LINK (Link);
Link = GetNextNode (&Question->OptionListHead, Link);
StringPtr = GetToken (OneOfOption->Text, MenuOption->Handle);
//
// If the string occupies multiple lines, truncate it to fit in one line,
// and append a "..." for indication.
//
if (EfiStrLen (StringPtr) > (PopUpWidth - 1)) {
TempStringPtr = EfiLibAllocateZeroPool (sizeof (CHAR16) * (PopUpWidth - 1));
ASSERT ( TempStringPtr != NULL );
EfiCopyMem (TempStringPtr, StringPtr, (sizeof (CHAR16) * (PopUpWidth - 5)));
gBS->FreePool (StringPtr);
StringPtr = TempStringPtr;
EfiStrCat (StringPtr, L"...");
}
if (Index == HighlightOptionIndex) {
//
// Highlight the selected one
//
CurrentOption = OneOfOption;
gST->ConOut->SetAttribute (gST->ConOut, PICKLIST_HIGHLIGHT_TEXT | PICKLIST_HIGHLIGHT_BACKGROUND);
PrintStringAt (Start + 2, Index2, StringPtr);
gST->ConOut->SetAttribute (gST->ConOut, POPUP_TEXT | POPUP_BACKGROUND);
} else {
gST->ConOut->SetAttribute (gST->ConOut, POPUP_TEXT | POPUP_BACKGROUND);
PrintStringAt (Start + 2, Index2, StringPtr);
}
Index2++;
gBS->FreePool (StringPtr);
}
Character = BOXDRAW_UP_RIGHT;
PrintCharAt (Start, Bottom, Character);
for (Index = Start; Index + 2 < End; Index++) {
if ((ShowDownArrow) && ((Index + 1) == (Start + End) / 2)) {
Character = GEOMETRICSHAPE_DOWN_TRIANGLE;
} else {
Character = BOXDRAW_HORIZONTAL;
}
PrintChar (Character);
}
Character = BOXDRAW_UP_LEFT;
PrintChar (Character);
//
// Get User selection
//
Key.UnicodeChar = CHAR_NULL;
if ((gDirection == SCAN_UP) || (gDirection == SCAN_DOWN)) {
Key.ScanCode = gDirection;
gDirection = 0;
goto TheKey;
}
Status = WaitForKeyStroke (&Key);
TheKey:
switch (Key.UnicodeChar) {
case '+':
if (OrderedList) {
if ((TopOptionIndex > 0) && (TopOptionIndex == HighlightOptionIndex)) {
//
// Highlight reaches the top of the popup window, scroll one menu item.
//
TopOptionIndex--;
ShowDownArrow = TRUE;
}
if (TopOptionIndex == 0) {
ShowUpArrow = FALSE;
}
if (HighlightOptionIndex > 0) {
HighlightOptionIndex--;
SwapListEntries (CurrentOption->Link.BackLink, &CurrentOption->Link);
}
}
break;
case '-':
//
// If an ordered list op-code, we will allow for a popup of +/- keys
// to create an ordered list of items
//
if (OrderedList) {
if (((TopOptionIndex + MenuLinesInView) < PopUpMenuLines) &&
(HighlightOptionIndex == (TopOptionIndex + MenuLinesInView - 1))) {
//
// Highlight reaches the bottom of the popup window, scroll one menu item.
//
TopOptionIndex++;
ShowUpArrow = TRUE;
}
if ((TopOptionIndex + MenuLinesInView) == PopUpMenuLines) {
ShowDownArrow = FALSE;
}
if (HighlightOptionIndex < (PopUpMenuLines - 1)) {
HighlightOptionIndex++;
SwapListEntries (&CurrentOption->Link, CurrentOption->Link.ForwardLink);
}
}
break;
case CHAR_NULL:
switch (Key.ScanCode) {
case SCAN_UP:
case SCAN_DOWN:
if (Key.ScanCode == SCAN_UP) {
if ((TopOptionIndex > 0) && (TopOptionIndex == HighlightOptionIndex)) {
//
// Highlight reaches the top of the popup window, scroll one menu item.
//
TopOptionIndex--;
ShowDownArrow = TRUE;
}
if (TopOptionIndex == 0) {
ShowUpArrow = FALSE;
}
if (HighlightOptionIndex > 0) {
HighlightOptionIndex--;
}
} else {
if (((TopOptionIndex + MenuLinesInView) < PopUpMenuLines) &&
(HighlightOptionIndex == (TopOptionIndex + MenuLinesInView - 1))) {
//
// Highlight reaches the bottom of the popup window, scroll one menu item.
//
TopOptionIndex++;
ShowUpArrow = TRUE;
}
if ((TopOptionIndex + MenuLinesInView) == PopUpMenuLines) {
ShowDownArrow = FALSE;
}
if (HighlightOptionIndex < (PopUpMenuLines - 1)) {
HighlightOptionIndex++;
}
}
break;
case SCAN_ESC:
gST->ConOut->SetAttribute (gST->ConOut, SavedAttribute);
//
// Restore link list order for orderedlist
//
if (OrderedList) {
HiiValue.Type = ValueType;
HiiValue.Value.u64 = 0;
for (Index = 0; Index < Question->MaxContainers; Index++) {
HiiValue.Value.u64 = GetArrayData (ValueArray, ValueType, Index);
if (HiiValue.Value.u64 == 0) {
break;
}
OneOfOption = ValueToOption (Question, &HiiValue);
if (OneOfOption == NULL) {
return EFI_NOT_FOUND;
}
RemoveEntryList (&OneOfOption->Link);
InsertTailList (&Question->OptionListHead, &OneOfOption->Link);
}
}
gBS->FreePool (HiiValueArray);
return EFI_DEVICE_ERROR;
default:
break;
}
break;
case CHAR_CARRIAGE_RETURN:
//
// return the current selection
//
if (OrderedList) {
Index = 0;
Link = GetFirstNode (&Question->OptionListHead);
while (!IsNull (&Question->OptionListHead, Link)) {
OneOfOption = QUESTION_OPTION_FROM_LINK (Link);
SetArrayData (ValueArray, ValueType, Index, OneOfOption->Value.Value.u64);
Index++;
if (Index > Question->MaxContainers) {
break;
}
Link = GetNextNode (&Question->OptionListHead, Link);
}
} else {
EfiCopyMem (&Question->HiiValue, &CurrentOption->Value, sizeof (EFI_HII_VALUE));
}
gST->ConOut->SetAttribute (gST->ConOut, SavedAttribute);
gBS->FreePool (HiiValueArray);
Status = ValidateQuestion (Selection->FormSet, Selection->Form, Question, EFI_HII_EXPRESSION_INCONSISTENT_IF);
if (EFI_ERROR (Status)) {
//
// Input value is not valid, restore Question Value
//
GetQuestionValue (Selection->FormSet, Selection->Form, Question, TRUE);
} else {
SetQuestionValue (Selection->FormSet, Selection->Form, Question, TRUE);
UpdateStatusBar (NV_UPDATE_REQUIRED, Question->QuestionFlags, TRUE);
}
return Status;
default:
break;
}
} while (TRUE);
//
// Code will not reach here
//
return EFI_SUCCESS;
}
EFI_STATUS
IfrToken (
IN FORM_BROWSER_FORMSET *FormSet,
OUT EFI_HII_VALUE *Result
)
/*++
Routine Description:
Evaluate opcode EFI_IFR_TOKEN.
Arguments:
FormSet - Formset which contains this opcode.
Result - Evaluation result for this opcode.
Returns:
EFI_SUCCESS - Opcode evaluation success.
Other - Opcode evaluation failed.
--*/
{
EFI_STATUS Status;
EFI_HII_VALUE Value;
CHAR16 *String[2];
UINTN Count;
CHAR16 *Delimiter;
CHAR16 *SubString;
CHAR16 *StringPtr;
UINTN Index;
Status = PopExpression (&Value);
if (EFI_ERROR (Status)) {
return Status;
}
if (Value.Type > EFI_IFR_TYPE_NUM_SIZE_64) {
return EFI_UNSUPPORTED;
}
Count = (UINTN) Value.Value.u64;
//
// String[0] - Delimiter
// String[1] - The string to search
//
String[0] = NULL;
String[1] = NULL;
for (Index = 0; Index < 2; Index++) {
Status = PopExpression (&Value);
if (EFI_ERROR (Status)) {
goto Done;
}
if (Value.Type != EFI_IFR_TYPE_STRING) {
Status = EFI_UNSUPPORTED;
goto Done;
}
String[Index] = GetToken (Value.Value.string, FormSet->HiiHandle);
if (String== NULL) {
Status = EFI_NOT_FOUND;
goto Done;
}
}
Delimiter = String[0];
SubString = String[1];
while (Count > 0) {
SubString = EfiStrStr (SubString, Delimiter);
if (SubString != NULL) {
//
// Skip over the delimiter
//
SubString = SubString + EfiStrLen (Delimiter);
} else {
break;
}
Count--;
}
if (SubString == NULL) {
//
// nth delimited sub-string not found, push an empty string
//
SubString = gEmptyString;
} else {
//
// Put a NULL terminator for nth delimited sub-string
//
StringPtr = EfiStrStr (SubString, Delimiter);
if (StringPtr != NULL) {
*StringPtr = L'\0';
}
}
Result->Type = EFI_IFR_TYPE_STRING;
Result->Value.string = NewString (SubString, FormSet->HiiHandle);
Done:
EfiLibSafeFreePool (String[0]);
EfiLibSafeFreePool (String[1]);
return Status;
}
EFI_STATUS
EFIAPI
StslRecordAssertion (
IN EFI_STANDARD_TEST_LIBRARY_PROTOCOL *This,
IN EFI_TEST_ASSERTION Type,
IN EFI_GUID EventId,
IN CHAR16 *Description,
IN CHAR16 *Detail,
...
)
/*++
Routine Description:
Records the test result.
Arguments:
This - Standard test library protocol instance.
Type - Test result.
EventId - GUID for the checkpoint.
Description - Simple description for the checkpoint.
Detail - Format string for the detail test information.
Returns:
EFI_SUCCESS - record the assertion successfully.
EFI_BAD_BUFFER_SIZE - the Description string is too long.
EFI_INVALID_PARAMETER - invalid Type.
--*/
{
EFI_STATUS Status;
VA_LIST Marker;
CHAR16 Buffer[EFI_MAX_PRINT_BUFFER];
CHAR16 AssertionType[10];
STANDARD_TEST_PRIVATE_DATA *Private;
Private = STANDARD_TEST_PRIVATE_DATA_FROM_STSL (This);
//
// Check the parameter
//
if (EfiStrLen (Description) + 14 > EFI_MAX_PRINT_BUFFER) {
return EFI_BAD_BUFFER_SIZE;
}
//
// Write log file detail data
//
switch (Type) {
case EFI_TEST_ASSERTION_PASSED:
EfiStrCpy (AssertionType, L"PASS");
Private->PassCount ++;
break;
case EFI_TEST_ASSERTION_WARNING:
EfiStrCpy (AssertionType, L"WARNING");
Private->WarningCount ++;
break;
case EFI_TEST_ASSERTION_FAILED:
EfiStrCpy (AssertionType, L"FAILURE");
Private->FailCount ++;
break;
default:
return EFI_INVALID_PARAMETER;
break;
}
SPrint (Buffer, EFI_MAX_PRINT_BUFFER, L"%s -- %s\n", Description, AssertionType);
Status = StslWriteLogFile (Private, Buffer);
if (EFI_ERROR (Status)) {
return Status;
}
SPrint (Buffer, EFI_MAX_PRINT_BUFFER, L"%g\n", &EventId);
Status = StslWriteLogFile (Private, Buffer);
if (EFI_ERROR (Status)) {
return Status;
}
VA_START(Marker, Detail);
VSPrint (Buffer, EFI_MAX_PRINT_BUFFER, Detail, Marker);
VA_END (Marker);
if ( EfiStrLen (Buffer) + 5 < EFI_MAX_PRINT_BUFFER ) {
EfiStrCat (Buffer, L"\r\n\r\n");
}
Status = StslWriteLogFile (Private, Buffer);
if (EFI_ERROR (Status)) {
return Status;
}
//
// write key file detail line
//
SPrint (Buffer, EFI_MAX_PRINT_BUFFER, L"%g:%s|%s:",
&EventId, AssertionType, Description);
Status = StslWriteKeyFile (Private, Buffer);
if (EFI_ERROR (Status)) {
return Status;
}
VA_START(Marker, Detail);
VSPrint (Buffer, EFI_MAX_PRINT_BUFFER, Detail, Marker);
VA_END (Marker);
if ( EfiStrLen (Buffer) + 3 < EFI_MAX_PRINT_BUFFER ) {
EfiStrCat (Buffer, L"\r\n");
}
Status = StslWriteKeyFile (Private, Buffer);
if (EFI_ERROR (Status)) {
return Status;
}
return Status;
}
EFI_STATUS
IfrMid (
IN FORM_BROWSER_FORMSET *FormSet,
OUT EFI_HII_VALUE *Result
)
/*++
Routine Description:
Evaluate opcode EFI_IFR_MID.
Arguments:
FormSet - Formset which contains this opcode.
Result - Evaluation result for this opcode.
Returns:
EFI_SUCCESS - Opcode evaluation success.
Other - Opcode evaluation failed.
--*/
{
EFI_STATUS Status;
EFI_HII_VALUE Value;
CHAR16 *String;
UINTN Base;
UINTN Length;
CHAR16 *SubString;
Status = PopExpression (&Value);
if (EFI_ERROR (Status)) {
return Status;
}
if (Value.Type > EFI_IFR_TYPE_NUM_SIZE_64) {
return EFI_UNSUPPORTED;
}
Length = (UINTN) Value.Value.u64;
Status = PopExpression (&Value);
if (EFI_ERROR (Status)) {
return Status;
}
if (Value.Type > EFI_IFR_TYPE_NUM_SIZE_64) {
return EFI_UNSUPPORTED;
}
Base = (UINTN) Value.Value.u64;
Status = PopExpression (&Value);
if (EFI_ERROR (Status)) {
return Status;
}
if (Value.Type != EFI_IFR_TYPE_STRING) {
return EFI_UNSUPPORTED;
}
String = GetToken (Value.Value.string, FormSet->HiiHandle);
if (String == NULL) {
return EFI_NOT_FOUND;
}
if (Length == 0 || Base >= EfiStrLen (String)) {
SubString = gEmptyString;
} else {
SubString = String + Base;
if ((Base + Length) < EfiStrLen (String)) {
SubString[Length] = L'\0';
}
}
Result->Type = EFI_IFR_TYPE_STRING;
Result->Value.string = NewString (SubString, FormSet->HiiHandle);
gBS->FreePool (String);
return Status;
}
EFI_STATUS
IfrFind (
IN FORM_BROWSER_FORMSET *FormSet,
IN UINT8 Format,
OUT EFI_HII_VALUE *Result
)
/*++
Routine Description:
Evaluate opcode EFI_IFR_FIND.
Arguments:
FormSet - Formset which contains this opcode.
Format - Case sensitive or insensitive.
Result - Evaluation result for this opcode.
Returns:
EFI_SUCCESS - Opcode evaluation success.
Other - Opcode evaluation failed.
--*/
{
EFI_STATUS Status;
EFI_HII_VALUE Value;
CHAR16 *String[2];
UINTN Base;
CHAR16 *StringPtr;
UINTN Index;
if (Format > EFI_IFR_FF_CASE_INSENSITIVE) {
return EFI_UNSUPPORTED;
}
Status = PopExpression (&Value);
if (EFI_ERROR (Status)) {
return Status;
}
if (Value.Type > EFI_IFR_TYPE_NUM_SIZE_64) {
return EFI_UNSUPPORTED;
}
Base = (UINTN) Value.Value.u64;
//
// String[0] - sub-string
// String[1] - The string to search
//
String[0] = NULL;
String[1] = NULL;
for (Index = 0; Index < 2; Index++) {
Status = PopExpression (&Value);
if (EFI_ERROR (Status)) {
goto Done;
}
if (Value.Type != EFI_IFR_TYPE_STRING) {
Status = EFI_UNSUPPORTED;
goto Done;
}
String[Index] = GetToken (Value.Value.string, FormSet->HiiHandle);
if (String== NULL) {
Status = EFI_NOT_FOUND;
goto Done;
}
if (Format == EFI_IFR_FF_CASE_INSENSITIVE) {
//
// Case insensitive, convert both string to upper case
//
IfrStrToUpper (String[Index]);
}
}
Result->Type = EFI_IFR_TYPE_NUM_SIZE_64;
if (Base >= EfiStrLen (String[1])) {
Result->Value.u64 = 0xFFFFFFFFFFFFFFFF;
} else {
StringPtr = EfiStrStr (String[1] + Base, String[0]);
Result->Value.u64 = (StringPtr == NULL) ? 0xFFFFFFFFFFFFFFFF : (StringPtr - String[1]);
}
Done:
EfiLibSafeFreePool (String[0]);
EfiLibSafeFreePool (String[1]);
return Status;
}
EFI_STATUS
EvaluateExpression (
IN FORM_BROWSER_FORMSET *FormSet,
IN FORM_BROWSER_FORM *Form,
IN OUT FORM_EXPRESSION *Expression
)
/*++
Routine Description:
Evaluate the result of a HII expression
Arguments:
FormSet - FormSet associated with this expression.
Form - Form associated with this expression.
Expression - Expression to be evaluated.
Returns:
EFI_SUCCESS - The expression evaluated successfuly
EFI_NOT_FOUND - The Question which referenced by a QuestionId could not be found.
EFI_OUT_OF_RESOURCES - There is not enough system memory to grow the stack.
EFI_ACCESS_DENIED - The pop operation underflowed the stack
EFI_INVALID_PARAMETER - Syntax error with the Expression
--*/
{
EFI_STATUS Status;
EFI_LIST_ENTRY *Link;
EXPRESSION_OPCODE *OpCode;
FORM_BROWSER_STATEMENT *Question;
FORM_BROWSER_STATEMENT *Question2;
UINT16 Index;
EFI_HII_VALUE Data1;
EFI_HII_VALUE Data2;
EFI_HII_VALUE Data3;
FORM_EXPRESSION *RuleExpression;
EFI_HII_VALUE *Value;
INTN Result;
CHAR16 *StrPtr;
//
// Always reset the stack before evaluating an Expression
//
ResetExpressionStack ();
Expression->Result.Type = EFI_IFR_TYPE_OTHER;
Link = GetFirstNode (&Expression->OpCodeListHead);
while (!IsNull (&Expression->OpCodeListHead, Link)) {
OpCode = EXPRESSION_OPCODE_FROM_LINK (Link);
Link = GetNextNode (&Expression->OpCodeListHead, Link);
EfiZeroMem (&Data1, sizeof (EFI_HII_VALUE));
EfiZeroMem (&Data2, sizeof (EFI_HII_VALUE));
EfiZeroMem (&Data3, sizeof (EFI_HII_VALUE));
Value = &Data3;
Value->Type = EFI_IFR_TYPE_BOOLEAN;
Status = EFI_SUCCESS;
switch (OpCode->Operand) {
//
// Built-in functions
//
case EFI_IFR_EQ_ID_VAL_OP:
Question = IdToQuestion (FormSet, Form, OpCode->QuestionId);
if (Question == NULL) {
return EFI_NOT_FOUND;
}
Result = CompareHiiValue (&Question->HiiValue, &OpCode->Value, NULL);
if (Result == EFI_INVALID_PARAMETER) {
return EFI_INVALID_PARAMETER;
}
Value->Value.b = (Result == 0) ? TRUE : FALSE;
break;
case EFI_IFR_EQ_ID_ID_OP:
Question = IdToQuestion (FormSet, Form, OpCode->QuestionId);
if (Question == NULL) {
return EFI_NOT_FOUND;
}
Question2 = IdToQuestion (FormSet, Form, OpCode->QuestionId2);
if (Question2 == NULL) {
return EFI_NOT_FOUND;
}
Result = CompareHiiValue (&Question->HiiValue, &Question2->HiiValue, FormSet->HiiHandle);
if (Result == EFI_INVALID_PARAMETER) {
return EFI_INVALID_PARAMETER;
}
Value->Value.b = (Result == 0) ? TRUE : FALSE;
break;
case EFI_IFR_EQ_ID_LIST_OP:
Question = IdToQuestion (FormSet, Form, OpCode->QuestionId);
if (Question == NULL) {
return EFI_NOT_FOUND;
}
Value->Value.b = FALSE;
for (Index =0; Index < OpCode->ListLength; Index++) {
if (Question->HiiValue.Value.u16 == OpCode->ValueList[Index]) {
Value->Value.b = TRUE;
break;
}
}
break;
case EFI_IFR_DUP_OP:
Status = PopExpression (Value);
if (EFI_ERROR (Status)) {
return Status;
}
Status = PushExpression (Value);
break;
case EFI_IFR_QUESTION_REF1_OP:
case EFI_IFR_THIS_OP:
Question = IdToQuestion (FormSet, Form, OpCode->QuestionId);
if (Question == NULL) {
return EFI_NOT_FOUND;
}
Value = &Question->HiiValue;
break;
case EFI_IFR_QUESTION_REF3_OP:
if (OpCode->DevicePath == 0) {
//
// EFI_IFR_QUESTION_REF3
// Pop an expression from the expression stack
//
Status = PopExpression (Value);
if (EFI_ERROR (Status)) {
return Status;
}
//
// Validate the expression value
//
if ((Value->Type > EFI_IFR_TYPE_NUM_SIZE_64) || (Value->Value.u64 > 0xffff)) {
return EFI_NOT_FOUND;
}
Question = IdToQuestion (FormSet, Form, Value->Value.u16);
if (Question == NULL) {
return EFI_NOT_FOUND;
}
//
// push the questions' value on to the expression stack
//
Value = &Question->HiiValue;
} else {
//
// BUGBUG: push 0 for EFI_IFR_QUESTION_REF3_2 and EFI_IFR_QUESTION_REF3_3,
// since it is impractical to evaluate the value of a Question in another
// Hii Package list.
//
EfiZeroMem (Value, sizeof (EFI_HII_VALUE));
}
break;
case EFI_IFR_RULE_REF_OP:
//
// Find expression for this rule
//
RuleExpression = RuleIdToExpression (Form, OpCode->RuleId);
if (RuleExpression == NULL) {
return EFI_NOT_FOUND;
}
//
// Evaluate this rule expression
//
Status = EvaluateExpression (FormSet, Form, RuleExpression);
if (EFI_ERROR (Status)) {
return Status;
}
Value = &RuleExpression->Result;
break;
case EFI_IFR_STRING_REF1_OP:
Value->Type = EFI_IFR_TYPE_STRING;
Value->Value.string = OpCode->Value.Value.string;
break;
//
// Constant
//
case EFI_IFR_TRUE_OP:
case EFI_IFR_FALSE_OP:
case EFI_IFR_ONE_OP:
case EFI_IFR_ONES_OP:
case EFI_IFR_UINT8_OP:
case EFI_IFR_UINT16_OP:
case EFI_IFR_UINT32_OP:
case EFI_IFR_UINT64_OP:
case EFI_IFR_UNDEFINED_OP:
case EFI_IFR_VERSION_OP:
case EFI_IFR_ZERO_OP:
Value = &OpCode->Value;
break;
//
// unary-op
//
case EFI_IFR_LENGTH_OP:
Status = PopExpression (Value);
if (EFI_ERROR (Status)) {
return Status;
}
if (Value->Type != EFI_IFR_TYPE_STRING) {
return EFI_INVALID_PARAMETER;
}
StrPtr = GetToken (Value->Value.string, FormSet->HiiHandle);
if (StrPtr == NULL) {
return EFI_INVALID_PARAMETER;
}
Value->Type = EFI_IFR_TYPE_NUM_SIZE_64;
Value->Value.u64 = EfiStrLen (StrPtr);
gBS->FreePool (StrPtr);
break;
case EFI_IFR_NOT_OP:
Status = PopExpression (Value);
if (EFI_ERROR (Status)) {
return Status;
}
if (Value->Type != EFI_IFR_TYPE_BOOLEAN) {
return EFI_INVALID_PARAMETER;
}
Value->Value.b = !Value->Value.b;
break;
case EFI_IFR_QUESTION_REF2_OP:
//
// Pop an expression from the expression stack
//
Status = PopExpression (Value);
if (EFI_ERROR (Status)) {
return Status;
}
//
// Validate the expression value
//
if ((Value->Type > EFI_IFR_TYPE_NUM_SIZE_64) || (Value->Value.u64 > 0xffff)) {
return EFI_NOT_FOUND;
}
Question = IdToQuestion (FormSet, Form, Value->Value.u16);
if (Question == NULL) {
return EFI_NOT_FOUND;
}
Value = &Question->HiiValue;
break;
case EFI_IFR_STRING_REF2_OP:
//
// Pop an expression from the expression stack
//
Status = PopExpression (Value);
if (EFI_ERROR (Status)) {
return Status;
}
//
// Validate the expression value
//
if ((Value->Type > EFI_IFR_TYPE_NUM_SIZE_64) || (Value->Value.u64 > 0xffff)) {
return EFI_NOT_FOUND;
}
Value->Type = EFI_IFR_TYPE_STRING;
StrPtr = GetToken (Value->Value.u16, FormSet->HiiHandle);
if (StrPtr == NULL) {
//
// If String not exit, push an empty string
//
Value->Value.string = NewString (gEmptyString, FormSet->HiiHandle);
} else {
Index = (UINT16) Value->Value.u64;
Value->Value.string = Index;
gBS->FreePool (StrPtr);
}
break;
case EFI_IFR_TO_BOOLEAN_OP:
//
// Pop an expression from the expression stack
//
Status = PopExpression (Value);
if (EFI_ERROR (Status)) {
return Status;
}
//
// Convert an expression to a Boolean
//
if (Value->Type <= EFI_IFR_TYPE_DATE) {
//
// When converting from an unsigned integer, zero will be converted to
// FALSE and any other value will be converted to TRUE.
//
Value->Value.b = (Value->Value.u64) ? TRUE : FALSE;
Value->Type = EFI_IFR_TYPE_BOOLEAN;
} else if (Value->Type == EFI_IFR_TYPE_STRING) {
//
// When converting from a string, if case-insensitive compare
// with "true" is True, then push True. If a case-insensitive compare
// with "false" is True, then push False.
//
StrPtr = GetToken (Value->Value.string, FormSet->HiiHandle);
if (StrPtr == NULL) {
return EFI_INVALID_PARAMETER;
}
if ((EfiStrCmp (StrPtr, L"true") == 0) || (EfiStrCmp (StrPtr, L"false") == 0)){
Value->Value.b = TRUE;
} else {
Value->Value.b = FALSE;
}
gBS->FreePool (StrPtr);
Value->Type = EFI_IFR_TYPE_BOOLEAN;
}
break;
case EFI_IFR_TO_STRING_OP:
Status = IfrToString (FormSet, OpCode->Format, Value);
break;
case EFI_IFR_TO_UINT_OP:
Status = IfrToUint (FormSet, Value);
break;
case EFI_IFR_TO_LOWER_OP:
case EFI_IFR_TO_UPPER_OP:
Status = InitializeUnicodeCollationProtocol ();
if (EFI_ERROR (Status)) {
return Status;
}
Status = PopExpression (Value);
if (EFI_ERROR (Status)) {
return Status;
}
if (Value->Type != EFI_IFR_TYPE_STRING) {
return EFI_UNSUPPORTED;
}
StrPtr = GetToken (Value->Value.string, FormSet->HiiHandle);
if (StrPtr == NULL) {
return EFI_NOT_FOUND;
}
if (OpCode->Operand == EFI_IFR_TO_LOWER_OP) {
mUnicodeCollation->StrLwr (mUnicodeCollation, StrPtr);
} else {
mUnicodeCollation->StrUpr (mUnicodeCollation, StrPtr);
}
Value->Value.string = NewString (StrPtr, FormSet->HiiHandle);
gBS->FreePool (StrPtr);
break;
case EFI_IFR_BITWISE_NOT_OP:
//
// Pop an expression from the expression stack
//
Status = PopExpression (Value);
if (EFI_ERROR (Status)) {
return Status;
}
if (Value->Type > EFI_IFR_TYPE_DATE) {
return EFI_INVALID_PARAMETER;
}
Value->Type = EFI_IFR_TYPE_NUM_SIZE_64;
Value->Value.u64 = ~Value->Value.u64;
break;
//
// binary-op
//
case EFI_IFR_ADD_OP:
case EFI_IFR_SUBTRACT_OP:
case EFI_IFR_MULTIPLY_OP:
case EFI_IFR_DIVIDE_OP:
case EFI_IFR_MODULO_OP:
case EFI_IFR_BITWISE_AND_OP:
case EFI_IFR_BITWISE_OR_OP:
case EFI_IFR_SHIFT_LEFT_OP:
case EFI_IFR_SHIFT_RIGHT_OP:
//
// Pop an expression from the expression stack
//
Status = PopExpression (&Data2);
if (EFI_ERROR (Status)) {
return Status;
}
if (Data2.Type > EFI_IFR_TYPE_DATE) {
return EFI_INVALID_PARAMETER;
}
//
// Pop another expression from the expression stack
//
Status = PopExpression (&Data1);
if (EFI_ERROR (Status)) {
return Status;
}
if (Data1.Type > EFI_IFR_TYPE_DATE) {
return EFI_INVALID_PARAMETER;
}
Value->Type = EFI_IFR_TYPE_NUM_SIZE_64;
switch (OpCode->Operand) {
case EFI_IFR_ADD_OP:
Value->Value.u64 = Data1.Value.u64 + Data2.Value.u64;
break;
case EFI_IFR_SUBTRACT_OP:
Value->Value.u64 = Data1.Value.u64 - Data2.Value.u64;
break;
case EFI_IFR_MULTIPLY_OP:
Value->Value.u64 = MultU64x32 (Data1.Value.u64, (UINTN) Data2.Value.u64);
break;
case EFI_IFR_DIVIDE_OP:
Value->Value.u64 = DivU64x32 (Data1.Value.u64, (UINTN) Data2.Value.u64, NULL);
break;
case EFI_IFR_MODULO_OP:
DivU64x32 (Data1.Value.u64, (UINTN) Data2.Value.u64, (UINTN *) &Value->Value.u64);
break;
case EFI_IFR_BITWISE_AND_OP:
Value->Value.u64 = Data1.Value.u64 & Data2.Value.u64;
break;
case EFI_IFR_BITWISE_OR_OP:
Value->Value.u64 = Data1.Value.u64 | Data2.Value.u64;
break;
case EFI_IFR_SHIFT_LEFT_OP:
Value->Value.u64 = LShiftU64 (Data1.Value.u64, (UINTN) Data2.Value.u64);
break;
case EFI_IFR_SHIFT_RIGHT_OP:
Value->Value.u64 = RShiftU64 (Data1.Value.u64, (UINTN) Data2.Value.u64);
break;
default:
break;
}
break;
case EFI_IFR_AND_OP:
case EFI_IFR_OR_OP:
//
// Two Boolean operator
//
Status = PopExpression (&Data2);
if (EFI_ERROR (Status)) {
return Status;
}
if (Data2.Type != EFI_IFR_TYPE_BOOLEAN) {
return EFI_INVALID_PARAMETER;
}
//
// Pop another expression from the expression stack
//
Status = PopExpression (&Data1);
if (EFI_ERROR (Status)) {
return Status;
}
if (Data1.Type != EFI_IFR_TYPE_BOOLEAN) {
return EFI_INVALID_PARAMETER;
}
if (OpCode->Operand == EFI_IFR_AND_OP) {
Value->Value.b = Data1.Value.b && Data2.Value.b;
} else {
Value->Value.b = Data1.Value.b || Data2.Value.b;
}
break;
case EFI_IFR_EQUAL_OP:
case EFI_IFR_NOT_EQUAL_OP:
case EFI_IFR_GREATER_EQUAL_OP:
case EFI_IFR_GREATER_THAN_OP:
case EFI_IFR_LESS_EQUAL_OP:
case EFI_IFR_LESS_THAN_OP:
//
// Compare two integer, string, boolean or date/time
//
Status = PopExpression (&Data2);
if (EFI_ERROR (Status)) {
return Status;
}
if (Data2.Type > EFI_IFR_TYPE_BOOLEAN && Data2.Type != EFI_IFR_TYPE_STRING) {
return EFI_INVALID_PARAMETER;
}
//
// Pop another expression from the expression stack
//
Status = PopExpression (&Data1);
if (EFI_ERROR (Status)) {
return Status;
}
Result = CompareHiiValue (&Data1, &Data2, FormSet->HiiHandle);
if (Result == EFI_INVALID_PARAMETER) {
return EFI_INVALID_PARAMETER;
}
switch (OpCode->Operand) {
case EFI_IFR_EQUAL_OP:
Value->Value.b = (Result == 0) ? TRUE : FALSE;
break;
case EFI_IFR_NOT_EQUAL_OP:
Value->Value.b = (Result != 0) ? TRUE : FALSE;
break;
case EFI_IFR_GREATER_EQUAL_OP:
Value->Value.b = (Result >= 0) ? TRUE : FALSE;
break;
case EFI_IFR_GREATER_THAN_OP:
Value->Value.b = (Result > 0) ? TRUE : FALSE;
break;
case EFI_IFR_LESS_EQUAL_OP:
Value->Value.b = (Result <= 0) ? TRUE : FALSE;
break;
case EFI_IFR_LESS_THAN_OP:
Value->Value.b = (Result < 0) ? TRUE : FALSE;
break;
default:
break;
}
break;
case EFI_IFR_MATCH_OP:
Status = IfrMatch (FormSet, Value);
break;
case EFI_IFR_CATENATE_OP:
Status = IfrCatenate (FormSet, Value);
break;
//
// ternary-op
//
case EFI_IFR_CONDITIONAL_OP:
//
// Pop third expression from the expression stack
//
Status = PopExpression (&Data3);
if (EFI_ERROR (Status)) {
return Status;
}
//
// Pop second expression from the expression stack
//
Status = PopExpression (&Data2);
if (EFI_ERROR (Status)) {
return Status;
}
//
// Pop first expression from the expression stack
//
Status = PopExpression (&Data1);
if (EFI_ERROR (Status)) {
return Status;
}
if (Data1.Type != EFI_IFR_TYPE_BOOLEAN) {
return EFI_INVALID_PARAMETER;
}
if (Data1.Value.b) {
Value = &Data3;
} else {
Value = &Data2;
}
break;
case EFI_IFR_FIND_OP:
Status = IfrFind (FormSet, OpCode->Format, Value);
break;
case EFI_IFR_MID_OP:
Status = IfrMid (FormSet, Value);
break;
case EFI_IFR_TOKEN_OP:
Status = IfrToken (FormSet, Value);
break;
case EFI_IFR_SPAN_OP:
Status = IfrSpan (FormSet, OpCode->Flags, Value);
break;
default:
break;
}
if (EFI_ERROR (Status)) {
return Status;
}
Status = PushExpression (Value);
if (EFI_ERROR (Status)) {
return Status;
}
}
//
// Pop the final result from expression stack
//
Value = &Data1;
Status = PopExpression (Value);
if (EFI_ERROR (Status)) {
return Status;
}
//
// After evaluating an expression, there should be only one value left on the expression stack
//
if (PopExpression (Value) != EFI_ACCESS_DENIED) {
return EFI_INVALID_PARAMETER;
}
EfiCopyMem (&Expression->Result, Value, sizeof (EFI_HII_VALUE));
return EFI_SUCCESS;
}
EFI_STATUS
IfrSpan (
IN FORM_BROWSER_FORMSET *FormSet,
IN UINT8 Flags,
OUT EFI_HII_VALUE *Result
)
/*++
Routine Description:
Evaluate opcode EFI_IFR_SPAN.
Arguments:
FormSet - Formset which contains this opcode.
Flags - FIRST_MATCHING or FIRST_NON_MATCHING.
Result - Evaluation result for this opcode.
Returns:
EFI_SUCCESS - Opcode evaluation success.
Other - Opcode evaluation failed.
--*/
{
EFI_STATUS Status;
EFI_HII_VALUE Value;
CHAR16 *String[2];
CHAR16 *Charset;
UINTN Base;
UINTN Index;
CHAR16 *StringPtr;
BOOLEAN Found;
Status = PopExpression (&Value);
if (EFI_ERROR (Status)) {
return Status;
}
if (Value.Type > EFI_IFR_TYPE_NUM_SIZE_64) {
return EFI_UNSUPPORTED;
}
Base = (UINTN) Value.Value.u64;
//
// String[0] - Charset
// String[1] - The string to search
//
String[0] = NULL;
String[1] = NULL;
for (Index = 0; Index < 2; Index++) {
Status = PopExpression (&Value);
if (EFI_ERROR (Status)) {
goto Done;
}
if (Value.Type != EFI_IFR_TYPE_STRING) {
Status = EFI_UNSUPPORTED;
goto Done;
}
String[Index] = GetToken (Value.Value.string, FormSet->HiiHandle);
if (String== NULL) {
Status = EFI_NOT_FOUND;
goto Done;
}
}
if (Base >= EfiStrLen (String[1])) {
Status = EFI_UNSUPPORTED;
goto Done;
}
Found = FALSE;
StringPtr = String[1] + Base;
Charset = String[0];
while (*StringPtr != 0 && !Found) {
Index = 0;
while (Charset[Index] != 0) {
if (*StringPtr >= Charset[Index] && *StringPtr <= Charset[Index + 1]) {
if (Flags == EFI_IFR_FLAGS_FIRST_MATCHING) {
Found = TRUE;
break;
}
} else {
if (Flags == EFI_IFR_FLAGS_FIRST_NON_MATCHING) {
Found = TRUE;
break;
}
}
//
// Skip characters pair representing low-end of a range and high-end of a range
//
Index += 2;
}
if (!Found) {
StringPtr++;
}
}
Result->Type = EFI_IFR_TYPE_NUM_SIZE_64;
Result->Value.u64 = StringPtr - String[1];
Done:
EfiLibSafeFreePool (String[0]);
EfiLibSafeFreePool (String[1]);
return Status;
}
UnicodeWeight[Index] == CHAR_CARRIAGE_RETURN) {
UnicodeWeight[Index] = 0;
}
}
for (Index = 0; Index < EfiStrLen (Buffer); Index++) {
StringIndex = (UINT16)Index;
Status = Hii->GetGlyph (Hii, UnicodeWeight, &StringIndex, (UINT8 **)&Glyph, &GlyphWidth, &GlyphStatus);
if (EFI_ERROR (Status)) {
goto Error;
}
if (Foreground == NULL || Background == NULL) {
Status = Hii->GlyphToBlt (Hii, (UINT8 *)Glyph, mEfiColors[Sto->Mode->Attribute & 0x0f], mEfiColors[Sto->Mode->Attribute >> 4], EfiStrLen (Buffer), GlyphWidth, GLYPH_HEIGHT, &LineBuffer[Index * GLYPH_WIDTH]);
} else {
Status = Hii->GlyphToBlt (Hii, (UINT8 *)Glyph, *Foreground, *Background, EfiStrLen (Buffer), GlyphWidth, GLYPH_HEIGHT, &LineBuffer[Index * GLYPH_WIDTH]);
}
}
//
// Blt a character to the screen
//
Status = GraphicsOutput->Blt (
GraphicsOutput,
LineBuffer,
EfiBltBufferToVideo,
0,
0,
X,
Y,
GLYPH_WIDTH * EfiStrLen (Buffer),
EFI_STATUS
BOpt_FindFiles (
IN BMM_CALLBACK_DATA *CallbackData,
IN BM_MENU_ENTRY *MenuEntry
)
/*++
Routine Description
Find files under current directory
All files and sub-directories in current directory
will be stored in DirectoryMenu for future use.
Arguments:
FileOption -- Pointer for Dir to explore
Returns:
TRUE -- Get files from current dir successfully
FALSE -- Can't get files from current dir
--*/
{
EFI_FILE_HANDLE NewDir;
EFI_FILE_HANDLE Dir;
EFI_FILE_INFO *DirInfo;
UINTN BufferSize;
UINTN DirBufferSize;
BM_MENU_ENTRY *NewMenuEntry;
BM_FILE_CONTEXT *FileContext;
BM_FILE_CONTEXT *NewFileContext;
UINTN Pass;
EFI_STATUS Status;
UINTN OptionNumber;
FileContext = (BM_FILE_CONTEXT *) MenuEntry->VariableContext;
Dir = FileContext->FHandle;
OptionNumber = 0;
//
// Open current directory to get files from it
//
Status = Dir->Open (
Dir,
&NewDir,
FileContext->FileName,
EFI_FILE_READ_ONLY,
0
);
if (!FileContext->IsRoot) {
Dir->Close (Dir);
}
if (EFI_ERROR (Status)) {
return Status;
}
DirInfo = EfiLibFileInfo (NewDir);
if (!DirInfo) {
return EFI_NOT_FOUND;
}
if (!(DirInfo->Attribute & EFI_FILE_DIRECTORY)) {
return EFI_INVALID_PARAMETER;
}
FileContext->DevicePath = EfiFileDevicePath (
FileContext->Handle,
FileContext->FileName
);
DirBufferSize = sizeof (EFI_FILE_INFO) + 1024;
DirInfo = EfiAllocateZeroPool (DirBufferSize);
if (!DirInfo) {
return EFI_OUT_OF_RESOURCES;
}
//
// Get all files in current directory
// Pass 1 to get Directories
// Pass 2 to get files that are EFI images
//
for (Pass = 1; Pass <= 2; Pass++) {
NewDir->SetPosition (NewDir, 0);
for (;;) {
BufferSize = DirBufferSize;
Status = NewDir->Read (NewDir, &BufferSize, DirInfo);
if (EFI_ERROR (Status) || BufferSize == 0) {
break;
}
if ((DirInfo->Attribute & EFI_FILE_DIRECTORY && Pass == 2) ||
(!(DirInfo->Attribute & EFI_FILE_DIRECTORY) && Pass == 1)
) {
//
// Pass 1 is for Directories
// Pass 2 is for file names
//
continue;
}
if (!(BOpt_IsEfiImageName (DirInfo->FileName) || DirInfo->Attribute & EFI_FILE_DIRECTORY)) {
//
// Slip file unless it is a directory entry or a .EFI file
//
continue;
}
NewMenuEntry = BOpt_CreateMenuEntry (BM_FILE_CONTEXT_SELECT);
if (NULL == NewMenuEntry) {
return EFI_OUT_OF_RESOURCES;
}
NewFileContext = (BM_FILE_CONTEXT *) NewMenuEntry->VariableContext;
NewFileContext->Handle = FileContext->Handle;
NewFileContext->FileName = BOpt_AppendFileName (
FileContext->FileName,
DirInfo->FileName
);
NewFileContext->FHandle = NewDir;
NewFileContext->DevicePath = EfiFileDevicePath (
NewFileContext->Handle,
NewFileContext->FileName
);
NewMenuEntry->HelpString = NULL;
MenuEntry->DisplayStringToken = GetStringTokenFromDepository (
CallbackData,
FileOptionStrDepository
);
NewFileContext->IsDir = (BOOLEAN) ((DirInfo->Attribute & EFI_FILE_DIRECTORY) == EFI_FILE_DIRECTORY);
if (NewFileContext->IsDir) {
BufferSize = EfiStrLen (DirInfo->FileName) * 2 + 6;
NewMenuEntry->DisplayString = EfiAllocateZeroPool (BufferSize);
SPrint (
NewMenuEntry->DisplayString,
BufferSize,
L"<%s>",
DirInfo->FileName
);
} else {
NewMenuEntry->DisplayString = EfiStrDuplicate (DirInfo->FileName);
}
NewFileContext->IsRoot = FALSE;
NewFileContext->IsLoadFile = FALSE;
NewFileContext->IsRemovableMedia = FALSE;
NewMenuEntry->OptionNumber = OptionNumber;
OptionNumber++;
InsertTailList (&DirectoryMenu.Head, &NewMenuEntry->Link);
}
}
DirectoryMenu.MenuNumber = OptionNumber;
SafeFreePool (DirInfo);
return EFI_SUCCESS;
}
UINTN
_IPrint (
IN EFI_GRAPHICS_OUTPUT_PROTOCOL *GraphicsOutput,
IN EFI_SIMPLE_TEXT_OUT_PROTOCOL *Sto,
IN UINTN X,
IN UINTN Y,
IN EFI_GRAPHICS_OUTPUT_BLT_PIXEL *Foreground,
IN EFI_GRAPHICS_OUTPUT_BLT_PIXEL *Background,
IN CHAR16 *fmt
)
{
VOID *Buffer;
EFI_STATUS Status;
UINT16 GlyphWidth;
UINT32 GlyphStatus;
UINT16 StringIndex;
UINTN Index;
CHAR16 *UnicodeWeight;
EFI_NARROW_GLYPH *Glyph;
UINTN Size;
EFI_HII_PROTOCOL *Hii;
EFI_HANDLE Handle;
EFI_GRAPHICS_OUTPUT_BLT_PIXEL *LineBuffer;
UINTN HorizontalResolution;
UINTN VerticalResolution;
GlyphStatus = 0;
//
// For now, allocate an arbitrarily long buffer
//
Status = gtBS->AllocatePool (EfiBootServicesData,
0x10000,
&Buffer);
CopyUnicodeString ((CHAR16*) Buffer, fmt);
HorizontalResolution = GraphicsOutput->Mode->Info->HorizontalResolution;
VerticalResolution = GraphicsOutput->Mode->Info->VerticalResolution;
Status = gtBS->AllocatePool (
EfiBootServicesData,
sizeof (EFI_GRAPHICS_OUTPUT_BLT_PIXEL) * HorizontalResolution * GLYPH_HEIGHT,
&LineBuffer
);
if (EFI_ERROR (Status)) {
gtBS->FreePool (Buffer);
return Status;
}
Size = sizeof (EFI_HANDLE);
Status = gtBS->LocateHandle (
ByProtocol,
&gEfiHiiProtocolGuid,
NULL,
&Size,
&Handle
);
if (EFI_ERROR (Status)) {
goto Error;
}
Status = gtBS->HandleProtocol (
Handle,
&gEfiHiiProtocolGuid,
&Hii
);
if (EFI_ERROR (Status)) {
goto Error;
}
UnicodeWeight = (CHAR16 *)Buffer;
for (Index = 0; UnicodeWeight[Index] != 0; Index++) {
if (UnicodeWeight[Index] == CHAR_BACKSPACE ||
UnicodeWeight[Index] == CHAR_LINEFEED ||
UnicodeWeight[Index] == CHAR_CARRIAGE_RETURN) {
UnicodeWeight[Index] = 0;
}
}
for (Index = 0; Index < EfiStrLen (Buffer); Index++) {
StringIndex = (UINT16)Index;
Status = Hii->GetGlyph (Hii, UnicodeWeight, &StringIndex, (UINT8 **)&Glyph, &GlyphWidth, &GlyphStatus);
if (EFI_ERROR (Status)) {
goto Error;
}
if (Foreground == NULL || Background == NULL) {
Status = Hii->GlyphToBlt (Hii, (UINT8 *)Glyph, mEfiColors[Sto->Mode->Attribute & 0x0f], mEfiColors[Sto->Mode->Attribute >> 4], EfiStrLen (Buffer), GlyphWidth, GLYPH_HEIGHT, &LineBuffer[Index * GLYPH_WIDTH]);
} else {
VOID
AlignmentItem (
IN CHAR16 *ControllerHandleName,
IN CHAR16 *PrefixString,
IN OUT CHAR16 **NewString
)
/*++
Routine Description:
Do controller item string swap and alignment if needed. The alignment is the length of PrefixString.
Because controller device path is too long sometime and cannot be presented in one line,
and the browser automatic swap will break the necessary alignment, so do some additional
process for the problem.
Arguments:
ControllerHandleName - a pointer to the controller real device path string
PrefixString- a pointer to the prefix string
NewString - a pointer to the string which will be presented by the browser
Returns:
None
--*/
{
CHAR16 *PadString;
UINTN PtrIndex;
UINTN IndexOffset;
UINTN Width;
CHAR16 *NewStringSwapped;
UINTN SwapLineNum;
UINTN SwapLine;
//
// Register the device name string and create item in set options page
//
*NewString = EfiLibAllocateZeroPool (EfiStrSize (ControllerHandleName) + EfiStrSize (PrefixString));
EfiStrCat (*NewString, PrefixString);
EfiStrCat (*NewString, ControllerHandleName);
//
// Add pad chars into the string for string swap in set options page to solve following two issue:
// Issue1: Our form browser will do the string swap according to the spaces in the string, so
// if a string is too long and without space in it, the string position will be ugly.
// The driver need add some spaces to control the swap in the long and no space string.
// Issue2: If browser find a space to do swap, it will not show any other space directly followed it in swap position.
// So if you want to use the space to do the alignment in swapped new line, you need add another char(e.g '.') in it.
// e.g. if the item max lenth is 5, then the following string need add some space and '.' to get right presentation
// '12345678901234567890' --------> ' 12345 . 67890 . 12345 . 67890' , and presentation is below
// | 12345
// |. 67890
// |. 12345
// |. 67890
//
if ((EfiStrLen (*NewString)/SWAP_LENGTH > 0) && (EfiStrLen (PrefixString) > 0)) {
//
// Prepare the pad string according to the PrefixString length
// the pad string is string of ' ', except of the NO2 charater which is '.'
//
PadString = EfiLibAllocateZeroPool (EfiStrSize (PrefixString) + 2);
for (PtrIndex = 0; PtrIndex < (EfiStrLen (PrefixString) + 1); PtrIndex++) {
PadString[PtrIndex] = ' ';
}
PadString[1] = '.';
Width = SWAP_LENGTH - EfiStrLen (PrefixString);
SwapLineNum = EfiStrLen (ControllerHandleName)/Width;
NewStringSwapped = EfiLibAllocateZeroPool (EfiStrSize (ControllerHandleName) +
EfiStrSize (PrefixString) +
SwapLineNum * EfiStrSize (PadString));
ASSERT (NewStringSwapped != NULL);
IndexOffset = 0;
EfiStrCpy (NewStringSwapped, PrefixString);
IndexOffset += EfiStrLen (PrefixString);
for (SwapLine = 0; SwapLine < SwapLineNum; SwapLine++) {
EfiStrnCpy (&NewStringSwapped[IndexOffset],
&ControllerHandleName[SwapLine * Width],
Width
);
IndexOffset += Width;
EfiStrnCpy (&NewStringSwapped[IndexOffset],
PadString,
EfiStrLen (PadString)
);
IndexOffset += EfiStrLen (PadString);
}
EfiStrCat (NewStringSwapped, &ControllerHandleName[SwapLine * Width]);
gBS->FreePool (PadString);
gBS->FreePool (*NewString);
*NewString = NewStringSwapped;
}
return;
}