audk/MdeModulePkg/Universal/SetupBrowserDxe/Expression.c

1939 lines
45 KiB
C

/** @file
Copyright (c) 2007, Intel Corporation
All rights reserved. This program and the accompanying materials
are licensed and made available under the terms and conditions of the BSD License
which accompanies this distribution. The full text of the license may be found at
http://opensource.org/licenses/bsd-license.php
THE PROGRAM IS DISTRIBUTED UNDER THE BSD LICENSE ON AN "AS IS" BASIS,
WITHOUT WARRANTIES OR REPRESENTATIONS OF ANY KIND, EITHER EXPRESS OR IMPLIED.
Module Name:
Expression.c
Abstract:
Expression evaluation.
**/
#include "Ui.h"
#include "Setup.h"
//
// Global stack used to evaluate boolean expresions
//
EFI_HII_VALUE *mOpCodeScopeStack = NULL;
EFI_HII_VALUE *mOpCodeScopeStackEnd = NULL;
EFI_HII_VALUE *mOpCodeScopeStackPointer = NULL;
EFI_HII_VALUE *mExpressionEvaluationStack = NULL;
EFI_HII_VALUE *mExpressionEvaluationStackEnd = NULL;
EFI_HII_VALUE *mExpressionEvaluationStackPointer = NULL;
//
// Unicode collation protocol interface
//
EFI_UNICODE_COLLATION_PROTOCOL *mUnicodeCollation = NULL;
/**
Grow size of the stack
@param Stack On input: old stack; On output: new stack
@param StackPtr On input: old stack pointer; On output: new stack
pointer
@param StackPtr On input: old stack end; On output: new stack end
@retval EFI_SUCCESS Grow stack success.
@retval EFI_OUT_OF_RESOURCES No enough memory for stack space.
**/
STATIC
EFI_STATUS
GrowStack (
IN OUT EFI_HII_VALUE **Stack,
IN OUT EFI_HII_VALUE **StackPtr,
IN OUT EFI_HII_VALUE **StackEnd
)
{
UINTN Size;
EFI_HII_VALUE *NewStack;
Size = EXPRESSION_STACK_SIZE_INCREMENT;
if (*StackPtr != NULL) {
Size = Size + (*StackEnd - *Stack);
}
NewStack = AllocatePool (Size * sizeof (EFI_HII_VALUE));
if (NewStack == NULL) {
return EFI_OUT_OF_RESOURCES;
}
if (*StackPtr != NULL) {
//
// Copy from Old Stack to the New Stack
//
CopyMem (
NewStack,
*Stack,
(*StackEnd - *Stack) * sizeof (EFI_HII_VALUE)
);
//
// Free The Old Stack
//
gBS->FreePool (*Stack);
}
//
// Make the Stack pointer point to the old data in the new stack
//
*StackPtr = NewStack + (*StackPtr - *Stack);
*Stack = NewStack;
*StackEnd = NewStack + Size;
return EFI_SUCCESS;
}
/**
Push an element onto the Boolean Stack
@param Stack On input: old stack; On output: new stack
@param StackPtr On input: old stack pointer; On output: new stack
pointer
@param StackPtr On input: old stack end; On output: new stack end
@param Data Data to push.
@retval EFI_SUCCESS Push stack success.
**/
EFI_STATUS
PushStack (
IN OUT EFI_HII_VALUE **Stack,
IN OUT EFI_HII_VALUE **StackPtr,
IN OUT EFI_HII_VALUE **StackEnd,
IN EFI_HII_VALUE *Data
)
{
EFI_STATUS Status;
//
// Check for a stack overflow condition
//
if (*StackPtr >= *StackEnd) {
//
// Grow the stack
//
Status = GrowStack (Stack, StackPtr, StackEnd);
if (EFI_ERROR (Status)) {
return Status;
}
}
//
// Push the item onto the stack
//
CopyMem (*StackPtr, Data, sizeof (EFI_HII_VALUE));
*StackPtr = *StackPtr + 1;
return EFI_SUCCESS;
}
/**
Pop an element from the stack.
@param Stack On input: old stack; On output: new stack
@param StackPtr On input: old stack pointer; On output: new stack
pointer
@param StackPtr On input: old stack end; On output: new stack end
@param Data Data to pop.
@retval EFI_SUCCESS The value was popped onto the stack.
@retval EFI_ACCESS_DENIED The pop operation underflowed the stack
**/
EFI_STATUS
PopStack (
IN OUT EFI_HII_VALUE **Stack,
IN OUT EFI_HII_VALUE **StackPtr,
IN OUT EFI_HII_VALUE **StackEnd,
OUT EFI_HII_VALUE *Data
)
{
//
// Check for a stack underflow condition
//
if (*StackPtr == *Stack) {
return EFI_ACCESS_DENIED;
}
//
// Pop the item off the stack
//
*StackPtr = *StackPtr - 1;
CopyMem (Data, *StackPtr, sizeof (EFI_HII_VALUE));
return EFI_SUCCESS;
}
/**
Reset stack pointer to begin of the stack.
None.
@return None.
**/
VOID
ResetScopeStack (
VOID
)
{
mOpCodeScopeStackPointer = mOpCodeScopeStack;
}
/**
Push an Operand onto the Stack
@param Operand Operand to push.
@retval EFI_SUCCESS The value was pushed onto the stack.
@retval EFI_OUT_OF_RESOURCES There is not enough system memory to grow the
stack.
**/
EFI_STATUS
PushScope (
IN UINT8 Operand
)
{
EFI_HII_VALUE Data;
Data.Type = EFI_IFR_TYPE_NUM_SIZE_8;
Data.Value.u8 = Operand;
return PushStack (
&mOpCodeScopeStack,
&mOpCodeScopeStackPointer,
&mOpCodeScopeStackEnd,
&Data
);
}
/**
Pop an Operand from the Stack
@param Operand Operand to pop.
@retval EFI_SUCCESS The value was pushed onto the stack.
@retval EFI_OUT_OF_RESOURCES There is not enough system memory to grow the
stack.
**/
EFI_STATUS
PopScope (
OUT UINT8 *Operand
)
{
EFI_STATUS Status;
EFI_HII_VALUE Data;
Status = PopStack (
&mOpCodeScopeStack,
&mOpCodeScopeStackPointer,
&mOpCodeScopeStackEnd,
&Data
);
*Operand = Data.Value.u8;
return Status;
}
/**
Reset stack pointer to begin of the stack.
None.
@return None.
**/
VOID
ResetExpressionStack (
VOID
)
{
mExpressionEvaluationStackPointer = mExpressionEvaluationStack;
}
/**
Push an Expression value onto the Stack
@param Value Expression value to push.
@retval EFI_SUCCESS The value was pushed onto the stack.
@retval EFI_OUT_OF_RESOURCES There is not enough system memory to grow the
stack.
**/
EFI_STATUS
PushExpression (
IN EFI_HII_VALUE *Value
)
{
return PushStack (
&mExpressionEvaluationStack,
&mExpressionEvaluationStackPointer,
&mExpressionEvaluationStackEnd,
Value
);
}
/**
Pop an Expression value from the stack.
@param Value Expression value to pop.
@retval EFI_SUCCESS The value was popped onto the stack.
@retval EFI_ACCESS_DENIED The pop operation underflowed the stack
**/
EFI_STATUS
PopExpression (
OUT EFI_HII_VALUE *Value
)
{
return PopStack (
&mExpressionEvaluationStack,
&mExpressionEvaluationStackPointer,
&mExpressionEvaluationStackEnd,
Value
);
}
/**
Get Form given its FormId.
@param FormSet The formset which contains this form.
@param FormId Id of this form.
@retval Pointer The form.
@retval NULL Specified Form is not found in the formset.
**/
FORM_BROWSER_FORM *
IdToForm (
IN FORM_BROWSER_FORMSET *FormSet,
IN UINT16 FormId
)
{
LIST_ENTRY *Link;
FORM_BROWSER_FORM *Form;
Link = GetFirstNode (&FormSet->FormListHead);
while (!IsNull (&FormSet->FormListHead, Link)) {
Form = FORM_BROWSER_FORM_FROM_LINK (Link);
if (Form->FormId == FormId) {
return Form;
}
Link = GetNextNode (&FormSet->FormListHead, Link);
}
return NULL;
}
/**
Search a Question in Form scope using its QuestionId.
@param Form The form which contains this Question.
@param QuestionId Id of this Question.
@retval Pointer The Question.
@retval NULL Specified Question not found in the form.
**/
FORM_BROWSER_STATEMENT *
IdToQuestion2 (
IN FORM_BROWSER_FORM *Form,
IN UINT16 QuestionId
)
{
LIST_ENTRY *Link;
FORM_BROWSER_STATEMENT *Question;
if (QuestionId == 0) {
//
// The value of zero is reserved
//
return NULL;
}
Link = GetFirstNode (&Form->StatementListHead);
while (!IsNull (&Form->StatementListHead, Link)) {
Question = FORM_BROWSER_STATEMENT_FROM_LINK (Link);
if (Question->QuestionId == QuestionId) {
return Question;
}
Link = GetNextNode (&Form->StatementListHead, Link);
}
return NULL;
}
/**
Search a Question in Formset scope using its QuestionId.
@param FormSet The formset which contains this form.
@param Form The form which contains this Question.
@param QuestionId Id of this Question.
@retval Pointer The Question.
@retval NULL Specified Question not found in the form.
**/
FORM_BROWSER_STATEMENT *
IdToQuestion (
IN FORM_BROWSER_FORMSET *FormSet,
IN FORM_BROWSER_FORM *Form,
IN UINT16 QuestionId
)
{
LIST_ENTRY *Link;
FORM_BROWSER_STATEMENT *Question;
//
// Search in the form scope first
//
Question = IdToQuestion2 (Form, QuestionId);
if (Question != NULL) {
return Question;
}
//
// Search in the formset scope
//
Link = GetFirstNode (&FormSet->FormListHead);
while (!IsNull (&FormSet->FormListHead, Link)) {
Form = FORM_BROWSER_FORM_FROM_LINK (Link);
Question = IdToQuestion2 (Form, QuestionId);
if (Question != NULL) {
return Question;
}
Link = GetNextNode (&FormSet->FormListHead, Link);
}
return NULL;
}
/**
Get Expression given its RuleId.
@param Form The form which contains this Expression.
@param RuleId Id of this Expression.
@retval Pointer The Expression.
@retval NULL Specified Expression not found in the form.
**/
FORM_EXPRESSION *
RuleIdToExpression (
IN FORM_BROWSER_FORM *Form,
IN UINT8 RuleId
)
{
LIST_ENTRY *Link;
FORM_EXPRESSION *Expression;
Link = GetFirstNode (&Form->ExpressionListHead);
while (!IsNull (&Form->ExpressionListHead, Link)) {
Expression = FORM_EXPRESSION_FROM_LINK (Link);
if (Expression->Type == EFI_HII_EXPRESSION_RULE && Expression->RuleId == RuleId) {
return Expression;
}
Link = GetNextNode (&Form->ExpressionListHead, Link);
}
return NULL;
}
/**
Locate the Unicode Collation Protocol interface for later use.
None.
@retval EFI_SUCCESS Protocol interface initialize success.
@retval Other Protocol interface initialize failed.
**/
EFI_STATUS
InitializeUnicodeCollationProtocol (
VOID
)
{
EFI_STATUS Status;
if (mUnicodeCollation != NULL) {
return EFI_SUCCESS;
}
//
// BUGBUG: Proper impelmentation is to locate all Unicode Collation Protocol
// instances first and then select one which support English language.
// Current implementation just pick the first instance.
//
Status = gBS->LocateProtocol (
&gEfiUnicodeCollation2ProtocolGuid,
NULL,
(VOID **) &mUnicodeCollation
);
return Status;
}
VOID
IfrStrToUpper (
CHAR16 *String
)
{
while (*String != 0) {
if ((*String >= 'a') && (*String <= 'z')) {
*String = (UINT16) ((*String) & ((UINT16) ~0x20));
}
String++;
}
}
/**
Evaluate opcode EFI_IFR_TO_STRING.
@param FormSet Formset which contains this opcode.
@param Format String format in EFI_IFR_TO_STRING.
@param Result Evaluation result for this opcode.
@retval EFI_SUCCESS Opcode evaluation success.
@retval Other Opcode evaluation failed.
**/
EFI_STATUS
IfrToString (
IN FORM_BROWSER_FORMSET *FormSet,
IN UINT8 Format,
OUT EFI_HII_VALUE *Result
)
{
EFI_STATUS Status;
EFI_HII_VALUE Value;
CHAR16 *String;
CHAR16 *PrintFormat;
CHAR16 Buffer[MAXIMUM_VALUE_CHARACTERS];
UINTN BufferSize;
Status = PopExpression (&Value);
if (EFI_ERROR (Status)) {
return Status;
}
switch (Value.Type) {
case EFI_IFR_TYPE_NUM_SIZE_8:
case EFI_IFR_TYPE_NUM_SIZE_16:
case EFI_IFR_TYPE_NUM_SIZE_32:
case EFI_IFR_TYPE_NUM_SIZE_64:
BufferSize = MAXIMUM_VALUE_CHARACTERS * sizeof (CHAR16);
switch (Format) {
case EFI_IFR_STRING_UNSIGNED_DEC:
case EFI_IFR_STRING_SIGNED_DEC:
PrintFormat = L"%ld";
break;
case EFI_IFR_STRING_LOWERCASE_HEX:
PrintFormat = L"%lx";
break;
case EFI_IFR_STRING_UPPERCASE_HEX:
PrintFormat = L"%lX";
break;
default:
return EFI_UNSUPPORTED;
}
UnicodeSPrint (Buffer, BufferSize, PrintFormat, Value.Value.u64);
String = Buffer;
break;
case EFI_IFR_TYPE_STRING:
CopyMem (Result, &Value, sizeof (EFI_HII_VALUE));
return EFI_SUCCESS;
case EFI_IFR_TYPE_BOOLEAN:
String = (Value.Value.b) ? L"True" : L"False";
break;
default:
return EFI_UNSUPPORTED;
}
Result->Type = EFI_IFR_TYPE_STRING;
Result->Value.string = NewString (String, FormSet->HiiHandle);
return EFI_SUCCESS;
}
/**
Evaluate opcode EFI_IFR_TO_UINT.
@param FormSet Formset which contains this opcode.
@param Result Evaluation result for this opcode.
@retval EFI_SUCCESS Opcode evaluation success.
@retval Other Opcode evaluation failed.
**/
EFI_STATUS
IfrToUint (
IN FORM_BROWSER_FORMSET *FormSet,
OUT EFI_HII_VALUE *Result
)
{
EFI_STATUS Status;
EFI_HII_VALUE Value;
CHAR16 *String;
CHAR16 *StringPtr;
UINTN BufferSize;
Status = PopExpression (&Value);
if (EFI_ERROR (Status)) {
return Status;
}
if (Value.Type >= EFI_IFR_TYPE_OTHER) {
return EFI_UNSUPPORTED;
}
Status = EFI_SUCCESS;
if (Value.Type == EFI_IFR_TYPE_STRING) {
String = GetToken (Value.Value.string, FormSet->HiiHandle);
if (String == NULL) {
return EFI_NOT_FOUND;
}
IfrStrToUpper (String);
StringPtr = StrStr (String, L"0X");
if (StringPtr != NULL) {
//
// Hex string
//
BufferSize = sizeof (UINT64);
Status = R8_HexStringToBuf ((UINT8 *) &Result->Value.u64, &BufferSize, StringPtr + 2, NULL);
} else {
//
// BUGBUG: Need handle decimal string
//
}
gBS->FreePool (String);
} else {
CopyMem (Result, &Value, sizeof (EFI_HII_VALUE));
}
Result->Type = EFI_IFR_TYPE_NUM_SIZE_64;
return Status;
}
/**
Evaluate opcode EFI_IFR_CATENATE.
@param FormSet Formset which contains this opcode.
@param Result Evaluation result for this opcode.
@retval EFI_SUCCESS Opcode evaluation success.
@retval Other Opcode evaluation failed.
**/
EFI_STATUS
IfrCatenate (
IN FORM_BROWSER_FORMSET *FormSet,
OUT EFI_HII_VALUE *Result
)
{
EFI_STATUS Status;
EFI_HII_VALUE Value;
CHAR16 *String[2];
UINTN Index;
CHAR16 *StringPtr;
UINTN Size;
//
// String[0] - The second string
// String[1] - The first string
//
String[0] = NULL;
String[1] = NULL;
StringPtr = NULL;
Status = EFI_SUCCESS;
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;
}
}
Size = StrSize (String[0]);
StringPtr= AllocatePool (StrSize (String[1]) + Size);
ASSERT (StringPtr != NULL);
StrCpy (StringPtr, String[1]);
StrCat (StringPtr, String[0]);
Result->Type = EFI_IFR_TYPE_STRING;
Result->Value.string = NewString (StringPtr, FormSet->HiiHandle);
Done:
SafeFreePool (String[0]);
SafeFreePool (String[1]);
SafeFreePool (StringPtr);
return Status;
}
/**
Evaluate opcode EFI_IFR_MATCH.
@param FormSet Formset which contains this opcode.
@param Result Evaluation result for this opcode.
@retval EFI_SUCCESS Opcode evaluation success.
@retval Other Opcode evaluation failed.
**/
EFI_STATUS
IfrMatch (
IN FORM_BROWSER_FORMSET *FormSet,
OUT EFI_HII_VALUE *Result
)
{
EFI_STATUS Status;
EFI_HII_VALUE Value;
CHAR16 *String[2];
UINTN Index;
//
// String[0] - The string to search
// String[1] - pattern
//
String[0] = NULL;
String[1] = NULL;
Status = EFI_SUCCESS;
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;
}
}
Result->Type = EFI_IFR_TYPE_BOOLEAN;
Result->Value.b = mUnicodeCollation->MetaiMatch (mUnicodeCollation, String[0], String[1]);
Done:
SafeFreePool (String[0]);
SafeFreePool (String[1]);
return Status;
}
/**
Evaluate opcode EFI_IFR_FIND.
@param FormSet Formset which contains this opcode.
@param Format Case sensitive or insensitive.
@param Result Evaluation result for this opcode.
@retval EFI_SUCCESS Opcode evaluation success.
@retval Other Opcode evaluation failed.
**/
EFI_STATUS
IfrFind (
IN FORM_BROWSER_FORMSET *FormSet,
IN UINT8 Format,
OUT EFI_HII_VALUE *Result
)
{
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 >= StrLen (String[1])) {
Result->Value.u64 = 0xFFFFFFFFFFFFFFFFULL;
} else {
StringPtr = StrStr (String[1] + Base, String[0]);
Result->Value.u64 = (StringPtr == NULL) ? 0xFFFFFFFFFFFFFFFFULL : (StringPtr - String[1]);
}
Done:
SafeFreePool (String[0]);
SafeFreePool (String[1]);
return Status;
}
/**
Evaluate opcode EFI_IFR_MID.
@param FormSet Formset which contains this opcode.
@param Result Evaluation result for this opcode.
@retval EFI_SUCCESS Opcode evaluation success.
@retval Other Opcode evaluation failed.
**/
EFI_STATUS
IfrMid (
IN FORM_BROWSER_FORMSET *FormSet,
OUT EFI_HII_VALUE *Result
)
{
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 >= StrLen (String)) {
SubString = gEmptyString;
} else {
SubString = String + Base;
if ((Base + Length) < StrLen (String)) {
SubString[Length] = L'\0';
}
}
Result->Type = EFI_IFR_TYPE_STRING;
Result->Value.string = NewString (SubString, FormSet->HiiHandle);
gBS->FreePool (String);
return Status;
}
/**
Evaluate opcode EFI_IFR_TOKEN.
@param FormSet Formset which contains this opcode.
@param Result Evaluation result for this opcode.
@retval EFI_SUCCESS Opcode evaluation success.
@retval Other Opcode evaluation failed.
**/
EFI_STATUS
IfrToken (
IN FORM_BROWSER_FORMSET *FormSet,
OUT EFI_HII_VALUE *Result
)
{
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 = StrStr (SubString, Delimiter);
if (SubString != NULL) {
//
// Skip over the delimiter
//
SubString = SubString + StrLen (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 = StrStr (SubString, Delimiter);
if (StringPtr != NULL) {
*StringPtr = L'\0';
}
}
Result->Type = EFI_IFR_TYPE_STRING;
Result->Value.string = NewString (SubString, FormSet->HiiHandle);
Done:
SafeFreePool (String[0]);
SafeFreePool (String[1]);
return Status;
}
/**
Evaluate opcode EFI_IFR_SPAN.
@param FormSet Formset which contains this opcode.
@param Flags FIRST_MATCHING or FIRST_NON_MATCHING.
@param Result Evaluation result for this opcode.
@retval EFI_SUCCESS Opcode evaluation success.
@retval Other Opcode evaluation failed.
**/
EFI_STATUS
IfrSpan (
IN FORM_BROWSER_FORMSET *FormSet,
IN UINT8 Flags,
OUT EFI_HII_VALUE *Result
)
{
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 >= StrLen (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:
SafeFreePool (String[0]);
SafeFreePool (String[1]);
return Status;
}
/**
Zero extend integer/boolean/date/time to UINT64 for comparing.
@param Value HII Value to be converted.
@return None.
**/
VOID
ExtendValueToU64 (
IN EFI_HII_VALUE *Value
)
{
UINT64 Temp;
Temp = 0;
switch (Value->Type) {
case EFI_IFR_TYPE_NUM_SIZE_8:
Temp = Value->Value.u8;
break;
case EFI_IFR_TYPE_NUM_SIZE_16:
Temp = Value->Value.u16;
break;
case EFI_IFR_TYPE_NUM_SIZE_32:
Temp = Value->Value.u32;
break;
case EFI_IFR_TYPE_BOOLEAN:
Temp = Value->Value.b;
break;
case EFI_IFR_TYPE_TIME:
Temp = Value->Value.u32 & 0xffffff;
break;
case EFI_IFR_TYPE_DATE:
Temp = Value->Value.u32;
break;
default:
return;
}
Value->Value.u64 = Temp;
}
/**
Compare two Hii value.
@param Value1 Expression value to compare on left-hand
@param Value2 Expression value to compare on right-hand
@param HiiHandle Only required for string compare
@retval EFI_INVALID_PARAMETER Could not perform comparation on two values
@retval 0 Two operators equeal
@retval 0 Value1 is greater than Value2
@retval 0 Value1 is less than Value2
**/
INTN
CompareHiiValue (
IN EFI_HII_VALUE *Value1,
IN EFI_HII_VALUE *Value2,
IN EFI_HII_HANDLE HiiHandle OPTIONAL
)
{
INTN Result;
INT64 Temp64;
CHAR16 *Str1;
CHAR16 *Str2;
if (Value1->Type >= EFI_IFR_TYPE_OTHER || Value2->Type >= EFI_IFR_TYPE_OTHER ) {
return EFI_INVALID_PARAMETER;
}
if (Value1->Type == EFI_IFR_TYPE_STRING || Value2->Type == EFI_IFR_TYPE_STRING ) {
if (Value1->Type != Value2->Type) {
//
// Both Operator should be type of String
//
return EFI_INVALID_PARAMETER;
}
if (Value1->Value.string == 0 || Value2->Value.string == 0) {
//
// StringId 0 is reserved
//
return EFI_INVALID_PARAMETER;
}
if (Value1->Value.string == Value2->Value.string) {
return 0;
}
Str1 = GetToken (Value1->Value.string, HiiHandle);
if (Str1 == NULL) {
//
// String not found
//
return EFI_INVALID_PARAMETER;
}
Str2 = GetToken (Value2->Value.string, HiiHandle);
if (Str2 == NULL) {
gBS->FreePool (Str1);
return EFI_INVALID_PARAMETER;
}
Result = StrCmp (Str1, Str2);
gBS->FreePool (Str1);
gBS->FreePool (Str2);
return Result;
}
//
// Take remain types(integer, boolean, date/time) as integer
//
Temp64 = (INT64) (Value1->Value.u64 - Value2->Value.u64);
if (Temp64 > 0) {
Result = 1;
} else if (Temp64 < 0) {
Result = -1;
} else {
Result = 0;
}
return Result;
}
/**
Evaluate the result of a HII expression
@param FormSet FormSet associated with this expression.
@param Form Form associated with this expression.
@param Expression Expression to be evaluated.
@retval EFI_SUCCESS The expression evaluated successfuly
@retval EFI_NOT_FOUND The Question which referenced by a QuestionId
could not be found.
@retval EFI_OUT_OF_RESOURCES There is not enough system memory to grow the
stack.
@retval EFI_ACCESS_DENIED The pop operation underflowed the stack
@retval EFI_INVALID_PARAMETER Syntax error with the Expression
**/
EFI_STATUS
EvaluateExpression (
IN FORM_BROWSER_FORMSET *FormSet,
IN FORM_BROWSER_FORM *Form,
IN OUT FORM_EXPRESSION *Expression
)
{
EFI_STATUS Status;
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;
UINT32 TempValue;
//
// 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);
ZeroMem (&Data1, sizeof (EFI_HII_VALUE));
ZeroMem (&Data2, sizeof (EFI_HII_VALUE));
ZeroMem (&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 = (BOOLEAN) ((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 = (BOOLEAN) ((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.
//
ZeroMem (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 = StrLen (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 = (BOOLEAN) (!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 = (BOOLEAN) ((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 ((StrCmp (StrPtr, L"true") == 0) || (StrCmp (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, (UINT32) Data2.Value.u64);
break;
case EFI_IFR_DIVIDE_OP:
Value->Value.u64 = DivU64x32 (Data1.Value.u64, (UINT32) Data2.Value.u64);
break;
case EFI_IFR_MODULO_OP:
DivU64x32Remainder (Data1.Value.u64, (UINT32) Data2.Value.u64, &TempValue);
Value->Value.u64 = TempValue;
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 = (BOOLEAN) (Data1.Value.b && Data2.Value.b);
} else {
Value->Value.b = (BOOLEAN) (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 = (BOOLEAN) ((Result == 0) ? TRUE : FALSE);
break;
case EFI_IFR_NOT_EQUAL_OP:
Value->Value.b = (BOOLEAN) ((Result == 0) ? TRUE : FALSE);
break;
case EFI_IFR_GREATER_EQUAL_OP:
Value->Value.b = (BOOLEAN) ((Result >= 0) ? TRUE : FALSE);
break;
case EFI_IFR_GREATER_THAN_OP:
Value->Value.b = (BOOLEAN) ((Result > 0) ? TRUE : FALSE);
break;
case EFI_IFR_LESS_EQUAL_OP:
Value->Value.b = (BOOLEAN) ((Result <= 0) ? TRUE : FALSE);
break;
case EFI_IFR_LESS_THAN_OP:
Value->Value.b = (BOOLEAN) ((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;
}
CopyMem (&Expression->Result, Value, sizeof (EFI_HII_VALUE));
return EFI_SUCCESS;
}