HiiExpression.c

Go to the documentation of this file.

 
#include "HiiInternal.h"
 
//
// Global stack used to evaluate boolean expressions
//
EFI_HII_VALUE  *mOpCodeScopeStack        = NULL;
EFI_HII_VALUE  *mOpCodeScopeStackEnd     = NULL;
EFI_HII_VALUE  *mOpCodeScopeStackPointer = NULL;
 
//
// Stack used for Suppressif/grayoutif/disableif expression list.
//
HII_EXPRESSION  **mFormExpressionStack   = NULL;
HII_EXPRESSION  **mFormExpressionEnd     = NULL;
HII_EXPRESSION  **mFormExpressionPointer = NULL;
 
HII_EXPRESSION  **mStatementExpressionStack   = NULL;
HII_EXPRESSION  **mStatementExpressionEnd     = NULL;
HII_EXPRESSION  **mStatementExpressionPointer = NULL;
 
HII_EXPRESSION  **mOptionExpressionStack   = NULL;
HII_EXPRESSION  **mOptionExpressionEnd     = NULL;
HII_EXPRESSION  **mOptionExpressionPointer = NULL;
 
//
// Stack used for the sub expresion in map expression.
//
EFI_HII_VALUE  *mCurrentExpressionStack   = NULL;
EFI_HII_VALUE  *mCurrentExpressionEnd     = NULL;
EFI_HII_VALUE  *mCurrentExpressionPointer = NULL;
 
//
// Stack used for the map expression list.
//
EFI_HII_VALUE  *mMapExpressionListStack   = NULL;
EFI_HII_VALUE  *mMapExpressionListEnd     = NULL;
EFI_HII_VALUE  *mMapExpressionListPointer = NULL;
 
//
// Stack used for dependency expression.
//
HII_DEPENDENCY_EXPRESSION  **mExpressionDependencyStack   = NULL;
HII_DEPENDENCY_EXPRESSION  **mExpressionDependencyEnd     = NULL;
HII_DEPENDENCY_EXPRESSION  **mExpressionDependencyPointer = NULL;
 
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
    //
    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;
}
 
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));
  if (Data->Type == EFI_IFR_TYPE_BUFFER) {
    (*StackPtr)->Buffer = AllocateCopyPool (Data->BufferLen, Data->Buffer);
    if ((*StackPtr)->Buffer == NULL) {
      return EFI_OUT_OF_RESOURCES;
    }
  }
 
  *StackPtr = *StackPtr + 1;
 
  return EFI_SUCCESS;
}
 
EFI_STATUS
PopStack (
  IN     EFI_HII_VALUE  *Stack,
  IN OUT EFI_HII_VALUE  **StackPtr,
  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;
}
 
VOID
ResetCurrentExpressionStack (
  VOID
  )
{
  mCurrentExpressionPointer   = mCurrentExpressionStack;
  mFormExpressionPointer      = mFormExpressionStack;
  mStatementExpressionPointer = mStatementExpressionStack;
  mOptionExpressionPointer    = mOptionExpressionStack;
}
 
EFI_STATUS
PushCurrentExpression (
  IN VOID  *Pointer
  )
{
  EFI_HII_VALUE  Data;
 
  Data.Type      = EFI_IFR_TYPE_NUM_SIZE_64;
  Data.Value.u64 = (UINT64)(UINTN)Pointer;
 
  return PushStack (
           &mCurrentExpressionStack,
           &mCurrentExpressionPointer,
           &mCurrentExpressionEnd,
           &Data
           );
}
 
EFI_STATUS
PopCurrentExpression (
  OUT VOID  **Pointer
  )
{
  EFI_STATUS     Status;
  EFI_HII_VALUE  Data;
 
  Status = PopStack (
             mCurrentExpressionStack,
             &mCurrentExpressionPointer,
             &Data
             );
 
  *Pointer = (VOID *)(UINTN)Data.Value.u64;
 
  return Status;
}
 
VOID
ResetMapExpressionListStack (
  VOID
  )
{
  mMapExpressionListPointer = mMapExpressionListStack;
}
 
EFI_STATUS
GrowConditionalStack (
  IN OUT HII_EXPRESSION  ***Stack,
  IN OUT HII_EXPRESSION  ***StackPtr,
  IN OUT HII_EXPRESSION  ***StackEnd,
  IN     UINTN           MemberSize
  )
{
  UINTN           Size;
  HII_EXPRESSION  **NewStack;
 
  Size = EXPRESSION_STACK_SIZE_INCREMENT;
  if (*StackPtr != NULL) {
    Size = Size + (*StackEnd - *Stack);
  }
 
  NewStack = AllocatePool (Size * MemberSize);
  if (NewStack == NULL) {
    return EFI_OUT_OF_RESOURCES;
  }
 
  if (*StackPtr != NULL) {
    //
    // Copy from Old Stack to the New Stack
    //
    CopyMem (
      NewStack,
      *Stack,
      (*StackEnd - *Stack) * MemberSize
      );
 
    //
    // Free The Old Stack
    //
    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;
}
 
EFI_STATUS
PushConditionalStack (
  IN OUT HII_EXPRESSION  ***Stack,
  IN OUT HII_EXPRESSION  ***StackPtr,
  IN OUT HII_EXPRESSION  ***StackEnd,
  IN     HII_EXPRESSION  **Data
  )
{
  EFI_STATUS  Status;
 
  //
  // Check for a stack overflow condition
  //
  if (*StackPtr >= *StackEnd) {
    //
    // Grow the stack
    //
    Status = GrowConditionalStack (Stack, StackPtr, StackEnd, sizeof (HII_EXPRESSION *));
    if (EFI_ERROR (Status)) {
      return Status;
    }
  }
 
  //
  // Push the item onto the stack
  //
  CopyMem (*StackPtr, Data, sizeof (HII_EXPRESSION *));
  *StackPtr = *StackPtr + 1;
 
  return EFI_SUCCESS;
}
 
EFI_STATUS
PopConditionalStack (
  IN     HII_EXPRESSION  **Stack,
  IN OUT HII_EXPRESSION  ***StackPtr,
  OUT HII_EXPRESSION     **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 (HII_EXPRESSION  *));
  return EFI_SUCCESS;
}
 
INTN
GetConditionalExpressionCount (
  IN EXPRESS_LEVEL  Level
  )
{
  switch (Level) {
    case ExpressForm:
      return mFormExpressionPointer - mFormExpressionStack;
    case ExpressStatement:
      return mStatementExpressionPointer - mStatementExpressionStack;
    case ExpressOption:
      return mOptionExpressionPointer - mOptionExpressionStack;
    default:
      ASSERT (FALSE);
      return -1;
  }
}
 
HII_EXPRESSION **
GetConditionalExpressionList (
  IN EXPRESS_LEVEL  Level
  )
{
  switch (Level) {
    case ExpressForm:
      return mFormExpressionStack;
    case ExpressStatement:
      return mStatementExpressionStack;
    case ExpressOption:
      return mOptionExpressionStack;
    default:
      ASSERT (FALSE);
      return NULL;
  }
}
 
EFI_STATUS
PushConditionalExpression (
  IN HII_EXPRESSION  *Pointer,
  IN EXPRESS_LEVEL   Level
  )
{
  switch (Level) {
    case ExpressForm:
      return PushConditionalStack (
               &mFormExpressionStack,
               &mFormExpressionPointer,
               &mFormExpressionEnd,
               &Pointer
               );
    case ExpressStatement:
      return PushConditionalStack (
               &mStatementExpressionStack,
               &mStatementExpressionPointer,
               &mStatementExpressionEnd,
               &Pointer
               );
    case ExpressOption:
      return PushConditionalStack (
               &mOptionExpressionStack,
               &mOptionExpressionPointer,
               &mOptionExpressionEnd,
               &Pointer
               );
    default:
      ASSERT (FALSE);
      return EFI_INVALID_PARAMETER;
  }
}
 
EFI_STATUS
PopConditionalExpression (
  IN EXPRESS_LEVEL  Level
  )
{
  HII_EXPRESSION  *Pointer;
 
  switch (Level) {
    case ExpressForm:
      return PopConditionalStack (
               mFormExpressionStack,
               &mFormExpressionPointer,
               &Pointer
               );
 
    case ExpressStatement:
      return PopConditionalStack (
               mStatementExpressionStack,
               &mStatementExpressionPointer,
               &Pointer
               );
 
    case ExpressOption:
      return PopConditionalStack (
               mOptionExpressionStack,
               &mOptionExpressionPointer,
               &Pointer
               );
 
    default:
      ASSERT (FALSE);
      return EFI_INVALID_PARAMETER;
  }
}
 
EFI_STATUS
PushMapExpressionList (
  IN VOID  *Pointer
  )
{
  EFI_HII_VALUE  Data;
 
  Data.Type      = EFI_IFR_TYPE_NUM_SIZE_64;
  Data.Value.u64 = (UINT64)(UINTN)Pointer;
 
  return PushStack (
           &mMapExpressionListStack,
           &mMapExpressionListPointer,
           &mMapExpressionListEnd,
           &Data
           );
}
 
EFI_STATUS
PopMapExpressionList (
  OUT VOID  **Pointer
  )
{
  EFI_STATUS     Status;
  EFI_HII_VALUE  Data;
 
  Status = PopStack (
             mMapExpressionListStack,
             &mMapExpressionListPointer,
             &Data
             );
 
  *Pointer = (VOID *)(UINTN)Data.Value.u64;
 
  return Status;
}
 
VOID
ResetScopeStack (
  VOID
  )
{
  mOpCodeScopeStackPointer = mOpCodeScopeStack;
}
 
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
           );
}
 
EFI_STATUS
PopScope (
  OUT UINT8  *Operand
  )
{
  EFI_STATUS     Status;
  EFI_HII_VALUE  Data;
 
  Status = PopStack (
             mOpCodeScopeStack,
             &mOpCodeScopeStackPointer,
             &Data
             );
 
  *Operand = Data.Value.u8;
 
  return Status;
}
 
EFI_STATUS
GrowDependencyStack (
  IN OUT HII_DEPENDENCY_EXPRESSION  ***Stack,
  IN OUT HII_DEPENDENCY_EXPRESSION  ***StackPtr,
  IN OUT HII_DEPENDENCY_EXPRESSION  ***StackEnd
  )
{
  UINTN                      Size;
  HII_DEPENDENCY_EXPRESSION  **NewStack;
 
  Size = EXPRESSION_STACK_SIZE_INCREMENT;
  if (*StackPtr != NULL) {
    Size = Size + (*StackEnd - *Stack);
  }
 
  NewStack = AllocatePool (Size * sizeof (HII_DEPENDENCY_EXPRESSION *));
  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 (HII_DEPENDENCY_EXPRESSION *)
      );
 
    //
    // Free The Old Stack
    //
    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;
}
 
EFI_STATUS
PushDependencyStack (
  IN OUT HII_DEPENDENCY_EXPRESSION  ***Stack,
  IN OUT HII_DEPENDENCY_EXPRESSION  ***StackPtr,
  IN OUT HII_DEPENDENCY_EXPRESSION  ***StackEnd,
  IN     HII_DEPENDENCY_EXPRESSION  **Data
  )
{
  EFI_STATUS  Status;
 
  //
  // Check for a stack overflow condition
  //
  if (*StackPtr >= *StackEnd) {
    //
    // Grow the stack
    //
    Status = GrowDependencyStack (Stack, StackPtr, StackEnd);
    if (EFI_ERROR (Status)) {
      return Status;
    }
  }
 
  //
  // Push the item onto the stack
  //
  CopyMem (*StackPtr, Data, sizeof (HII_DEPENDENCY_EXPRESSION *));
  *StackPtr = *StackPtr + 1;
 
  return EFI_SUCCESS;
}
 
EFI_STATUS
PopDependencyStack (
  IN     HII_DEPENDENCY_EXPRESSION  **Stack,
  IN OUT HII_DEPENDENCY_EXPRESSION  ***StackPtr,
  OUT HII_DEPENDENCY_EXPRESSION     **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 (HII_DEPENDENCY_EXPRESSION *));
  return EFI_SUCCESS;
}
 
EFI_STATUS
PushDependencyExpDes (
  IN HII_DEPENDENCY_EXPRESSION  **Pointer
  )
{
  return PushDependencyStack (
           &mExpressionDependencyStack,
           &mExpressionDependencyPointer,
           &mExpressionDependencyEnd,
           Pointer
           );
}
 
EFI_STATUS
PopDependencyExpDes (
  OUT HII_DEPENDENCY_EXPRESSION  **Pointer
  )
{
  return PopDependencyStack (
           mExpressionDependencyStack,
           &mExpressionDependencyPointer,
           Pointer
           );
}
 
EFI_STATUS
GetHiiExpressionDependency (
  IN OUT HII_EXPRESSION  *Expression
  )
{
  EFI_STATUS                 Status;
  LIST_ENTRY                 *Link;
  HII_EXPRESSION_OPCODE      *ExpressionOpCode;
  HII_DEPENDENCY_EXPRESSION  *DepExpressionOpCode;
  LIST_ENTRY                 *SubExpressionLink;
  HII_EXPRESSION             *SubExpression;
  UINT8                      MapPairCount;
 
  Link = GetFirstNode (&Expression->OpCodeListHead);
  while (!IsNull (&Expression->OpCodeListHead, Link)) {
    ExpressionOpCode = HII_EXPRESSION_OPCODE_FROM_LINK (Link);
    Link             = GetNextNode (&Expression->OpCodeListHead, Link);
    Status           = EFI_SUCCESS;
 
    DepExpressionOpCode = (HII_DEPENDENCY_EXPRESSION *)AllocateZeroPool (sizeof (HII_DEPENDENCY_EXPRESSION));
    if (DepExpressionOpCode == NULL) {
      return EFI_OUT_OF_RESOURCES;
    }
 
    switch (ExpressionOpCode->Operand) {
      //
      // Constant
      //
      case EFI_IFR_FALSE_OP:
      case EFI_IFR_ONE_OP:
      case EFI_IFR_ONES_OP:
      case EFI_IFR_TRUE_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:
        DepExpressionOpCode->ConstantExp.Operand = ExpressionOpCode->Operand;
        CopyMem (&DepExpressionOpCode->ConstantExp.Value, &ExpressionOpCode->ExtraData.Value, sizeof (EFI_HII_VALUE));
        PushDependencyExpDes (&DepExpressionOpCode);
        break;
 
      //
      // Built-in functions
      //
      case EFI_IFR_DUP_OP:
        DepExpressionOpCode->DupExp.Operand = ExpressionOpCode->Operand;
        PushDependencyExpDes (&DepExpressionOpCode);
        break;
 
      case EFI_IFR_EQ_ID_VAL_OP:
        DepExpressionOpCode->EqIdValExp.Operand = ExpressionOpCode->Operand;
        CopyMem (&DepExpressionOpCode->EqIdValExp.QuestionId, &ExpressionOpCode->ExtraData.EqIdValData.QuestionId, sizeof (EFI_QUESTION_ID));
        CopyMem (&DepExpressionOpCode->EqIdValExp.Value, &ExpressionOpCode->ExtraData.EqIdValData.Value, sizeof (EFI_HII_VALUE));
        PushDependencyExpDes (&DepExpressionOpCode);
        break;
 
      case EFI_IFR_EQ_ID_ID_OP:
        DepExpressionOpCode->EqIdIdExp.Operand = ExpressionOpCode->Operand;
        CopyMem (&DepExpressionOpCode->EqIdIdExp.QuestionId1, &ExpressionOpCode->ExtraData.EqIdIdData.QuestionId1, sizeof (EFI_QUESTION_ID));
        CopyMem (&DepExpressionOpCode->EqIdIdExp.QuestionId2, &ExpressionOpCode->ExtraData.EqIdIdData.QuestionId2, sizeof (EFI_QUESTION_ID));
        PushDependencyExpDes (&DepExpressionOpCode);
        break;
 
      case EFI_IFR_EQ_ID_VAL_LIST_OP:
        DepExpressionOpCode->EqIdListExp.Operand    = ExpressionOpCode->Operand;
        DepExpressionOpCode->EqIdListExp.ListLength = ExpressionOpCode->ExtraData.EqIdListData.ListLength;
        CopyMem (&DepExpressionOpCode->EqIdListExp.QuestionId, &ExpressionOpCode->ExtraData.EqIdListData.QuestionId, sizeof (EFI_QUESTION_ID));
        PushDependencyExpDes (&DepExpressionOpCode);
        DepExpressionOpCode->EqIdListExp.ValueList = AllocateCopyPool (
                                                       DepExpressionOpCode->EqIdListExp.ListLength * sizeof (UINT16),
                                                       ExpressionOpCode->ExtraData.EqIdListData.ValueList
                                                       );
        if (DepExpressionOpCode->EqIdListExp.ValueList == NULL) {
          return EFI_OUT_OF_RESOURCES;
        }
 
        PushDependencyExpDes (&DepExpressionOpCode);
        break;
 
      case EFI_IFR_GET_OP:
        DepExpressionOpCode->GetExp.Operand    = ExpressionOpCode->Operand;
        DepExpressionOpCode->GetExp.VarStorage = ExpressionOpCode->ExtraData.GetSetData.VarStorage;
        CopyMem (&DepExpressionOpCode->GetExp.VarStoreInfo.VarName, &ExpressionOpCode->ExtraData.GetSetData.VarStoreInfo.VarName, sizeof (EFI_STRING_ID));
        CopyMem (&DepExpressionOpCode->GetExp.VarStoreInfo.VarOffset, &ExpressionOpCode->ExtraData.GetSetData.VarStoreInfo.VarOffset, sizeof (UINT16));
        DepExpressionOpCode->GetExp.VarStoreInfo = ExpressionOpCode->ExtraData.GetSetData.VarStoreInfo;
        if (ExpressionOpCode->ExtraData.GetSetData.ValueName != NULL) {
          DepExpressionOpCode->GetExp.ValueName = (CHAR16 *)AllocateCopyPool (sizeof (ExpressionOpCode->ExtraData.GetSetData.ValueName), ExpressionOpCode->ExtraData.GetSetData.ValueName);
          if (DepExpressionOpCode->GetExp.ValueName == NULL) {
            return EFI_OUT_OF_RESOURCES;
          }
        }
 
        DepExpressionOpCode->GetExp.ValueType  = ExpressionOpCode->ExtraData.GetSetData.ValueType;
        DepExpressionOpCode->GetExp.ValueWidth = ExpressionOpCode->ExtraData.GetSetData.ValueWidth;
        PushDependencyExpDes (&DepExpressionOpCode);
        break;
 
      case EFI_IFR_QUESTION_REF1_OP:
        DepExpressionOpCode->QuestionRef1Exp.Operand = ExpressionOpCode->Operand;
        CopyMem (&DepExpressionOpCode->QuestionRef1Exp.QuestionId, &ExpressionOpCode->ExtraData.QuestionRef1Data.QuestionId, sizeof (EFI_QUESTION_ID));
        PushDependencyExpDes (&DepExpressionOpCode);
        break;
 
      case EFI_IFR_RULE_REF_OP:
        DepExpressionOpCode->RuleRefExp.Operand = ExpressionOpCode->Operand;
        DepExpressionOpCode->RuleRefExp.RuleId  = ExpressionOpCode->ExtraData.RuleId;
        PushDependencyExpDes (&DepExpressionOpCode);
        break;
 
      case EFI_IFR_STRING_REF1_OP:
        DepExpressionOpCode->StringRef1Exp.Operand = ExpressionOpCode->Operand;
        CopyMem (&DepExpressionOpCode->StringRef1Exp.Value.Value.string, &ExpressionOpCode->ExtraData.Value.Value.string, sizeof (EFI_STRING_ID));
        PushDependencyExpDes (&DepExpressionOpCode);
        break;
 
      case EFI_IFR_THIS_OP:
        DepExpressionOpCode->ThisExp.Operand = ExpressionOpCode->Operand;
        CopyMem (&DepExpressionOpCode->ThisExp.QuestionId, &ExpressionOpCode->ExtraData.QuestionRef1Data.QuestionId, sizeof (EFI_QUESTION_ID));
        PushDependencyExpDes (&DepExpressionOpCode);
        break;
 
      case EFI_IFR_SECURITY_OP:
        DepExpressionOpCode->SecurityExp.Operand = ExpressionOpCode->Operand;
        CopyMem (&DepExpressionOpCode->SecurityExp.Permissions, &ExpressionOpCode->ExtraData.Guid, sizeof (EFI_GUID));
        PushDependencyExpDes (&DepExpressionOpCode);
        break;
 
      //
      // unary-op
      //
      case EFI_IFR_LENGTH_OP:
        DepExpressionOpCode->LengthExp.Operand = ExpressionOpCode->Operand;
        PopDependencyExpDes (&DepExpressionOpCode->LengthExp.SubExpression);
        PushDependencyExpDes (&DepExpressionOpCode);
        break;
 
      case EFI_IFR_NOT_OP:
        DepExpressionOpCode->NotExp.Operand = ExpressionOpCode->Operand;
        PopDependencyExpDes (&DepExpressionOpCode->NotExp.SubExpression);
        PushDependencyExpDes (&DepExpressionOpCode);
        break;
 
      case EFI_IFR_BITWISE_NOT_OP:
        DepExpressionOpCode->BitWiseNotExp.Operand = ExpressionOpCode->Operand;
        PopDependencyExpDes (&DepExpressionOpCode->BitWiseNotExp.SubExpression);
        PushDependencyExpDes (&DepExpressionOpCode);
        break;
 
      case EFI_IFR_QUESTION_REF2_OP:
        DepExpressionOpCode->QuestionRef2Exp.Operand = ExpressionOpCode->Operand;
        PopDependencyExpDes (&DepExpressionOpCode->QuestionRef2Exp.SubExpression);
        PushDependencyExpDes (&DepExpressionOpCode);
        break;
 
      case EFI_IFR_QUESTION_REF3_OP:
        DepExpressionOpCode->QuestionRef3Exp.Operand = ExpressionOpCode->Operand;
        CopyMem (&DepExpressionOpCode->QuestionRef3Exp.DevicePath, &ExpressionOpCode->ExtraData.QuestionRef3Data.DevicePath, sizeof (EFI_DEVICE_PATH));
        CopyMem (&DepExpressionOpCode->QuestionRef3Exp.Guid, &ExpressionOpCode->ExtraData.QuestionRef3Data.Guid, sizeof (EFI_GUID));
        PopDependencyExpDes (&DepExpressionOpCode->QuestionRef3Exp.SubExpression);
        PushDependencyExpDes (&DepExpressionOpCode);
        break;
 
      case EFI_IFR_SET_OP:
        DepExpressionOpCode->SetExp.Operand    = ExpressionOpCode->Operand;
        DepExpressionOpCode->SetExp.VarStorage = ExpressionOpCode->ExtraData.GetSetData.VarStorage;
        CopyMem (&DepExpressionOpCode->SetExp.VarStoreInfo.VarName, &ExpressionOpCode->ExtraData.GetSetData.VarStoreInfo.VarName, sizeof (EFI_STRING_ID));
        CopyMem (&DepExpressionOpCode->SetExp.VarStoreInfo.VarOffset, &ExpressionOpCode->ExtraData.GetSetData.VarStoreInfo.VarOffset, sizeof (UINT16));
        DepExpressionOpCode->SetExp.VarStoreInfo = ExpressionOpCode->ExtraData.GetSetData.VarStoreInfo;
        if (ExpressionOpCode->ExtraData.GetSetData.ValueName != NULL) {
          DepExpressionOpCode->SetExp.ValueName = (CHAR16 *)AllocateCopyPool (sizeof (ExpressionOpCode->ExtraData.GetSetData.ValueName), ExpressionOpCode->ExtraData.GetSetData.ValueName);
          if (DepExpressionOpCode->SetExp.ValueName == NULL) {
            return EFI_OUT_OF_RESOURCES;
          }
        }
 
        DepExpressionOpCode->SetExp.ValueType  = ExpressionOpCode->ExtraData.GetSetData.ValueType;
        DepExpressionOpCode->SetExp.ValueWidth = ExpressionOpCode->ExtraData.GetSetData.ValueWidth;
        PopDependencyExpDes (&DepExpressionOpCode->SetExp.SubExpression);
        PushDependencyExpDes (&DepExpressionOpCode);
        break;
 
      case EFI_IFR_STRING_REF2_OP:
        DepExpressionOpCode->StringRef2Exp.Operand = ExpressionOpCode->Operand;
        PopDependencyExpDes (&DepExpressionOpCode->StringRef2Exp.SubExpression);
        PushDependencyExpDes (&DepExpressionOpCode);
        break;
 
      case EFI_IFR_TO_BOOLEAN_OP:
        DepExpressionOpCode->ToBooleanExp.Operand = ExpressionOpCode->Operand;
        PopDependencyExpDes (&DepExpressionOpCode->ToBooleanExp.SubExpression);
        PushDependencyExpDes (&DepExpressionOpCode);
        break;
 
      case EFI_IFR_TO_STRING_OP:
        DepExpressionOpCode->ToStringExp.Operand = ExpressionOpCode->Operand;
        DepExpressionOpCode->ToStringExp.Format  = ExpressionOpCode->ExtraData.Format;
        PopDependencyExpDes (&DepExpressionOpCode->ToStringExp.SubExpression);
        PushDependencyExpDes (&DepExpressionOpCode);
        break;
 
      case EFI_IFR_TO_UINT_OP:
        DepExpressionOpCode->ToUintExp.Operand = ExpressionOpCode->Operand;
        PopDependencyExpDes (&DepExpressionOpCode->ToUintExp.SubExpression);
        PushDependencyExpDes (&DepExpressionOpCode);
        break;
 
      case EFI_IFR_TO_LOWER_OP:
        DepExpressionOpCode->ToLowerExp.Operand = ExpressionOpCode->Operand;
        PopDependencyExpDes (&DepExpressionOpCode->ToLowerExp.SubExpression);
        PushDependencyExpDes (&DepExpressionOpCode);
        break;
 
      case EFI_IFR_TO_UPPER_OP:
        DepExpressionOpCode->ToUpperExp.Operand = ExpressionOpCode->Operand;
        PopDependencyExpDes (&DepExpressionOpCode->ToUpperExp.SubExpression);
        PushDependencyExpDes (&DepExpressionOpCode);
        break;
 
      //
      // binary-op
      //
      case EFI_IFR_ADD_OP:
        DepExpressionOpCode->AddExp.Operand = ExpressionOpCode->Operand;
        PopDependencyExpDes (&DepExpressionOpCode->AddExp.LeftHandExp);
        PopDependencyExpDes (&DepExpressionOpCode->AddExp.RightHandExp);
        PushDependencyExpDes (&DepExpressionOpCode);
        break;
 
      case EFI_IFR_AND_OP:
        DepExpressionOpCode->AndExp.Operand = ExpressionOpCode->Operand;
        PopDependencyExpDes (&DepExpressionOpCode->AndExp.SubExpression1);
        PopDependencyExpDes (&DepExpressionOpCode->AndExp.SubExpression2);
        PushDependencyExpDes (&DepExpressionOpCode);
        break;
 
      case EFI_IFR_BITWISE_AND_OP:
        DepExpressionOpCode->BitwiseAndExp.Operand = ExpressionOpCode->Operand;
        PopDependencyExpDes (&DepExpressionOpCode->BitwiseAndExp.SubExpression1);
        PopDependencyExpDes (&DepExpressionOpCode->BitwiseAndExp.SubExpression2);
        PushDependencyExpDes (&DepExpressionOpCode);
        break;
 
      case EFI_IFR_BITWISE_OR_OP:
        DepExpressionOpCode->BitwiseOrExp.Operand = ExpressionOpCode->Operand;
        PopDependencyExpDes (&DepExpressionOpCode->BitwiseOrExp.SubExpression1);
        PopDependencyExpDes (&DepExpressionOpCode->BitwiseOrExp.SubExpression2);
        PushDependencyExpDes (&DepExpressionOpCode);
        break;
 
      case EFI_IFR_CATENATE_OP:
        DepExpressionOpCode->CatenateExp.Operand = ExpressionOpCode->Operand;
        PopDependencyExpDes (&DepExpressionOpCode->CatenateExp.LeftStringExp);
        PopDependencyExpDes (&DepExpressionOpCode->CatenateExp.RightStringExp);
        PushDependencyExpDes (&DepExpressionOpCode);
        break;
 
      case EFI_IFR_DIVIDE_OP:
        DepExpressionOpCode->DivExp.Operand = ExpressionOpCode->Operand;
        PopDependencyExpDes (&DepExpressionOpCode->DivExp.LeftHandExp);
        PopDependencyExpDes (&DepExpressionOpCode->DivExp.RightHandExp);
        PushDependencyExpDes (&DepExpressionOpCode);
        break;
 
      case EFI_IFR_EQUAL_OP:
        DepExpressionOpCode->EqualExp.Operand = ExpressionOpCode->Operand;
        PopDependencyExpDes (&DepExpressionOpCode->EqualExp.SubExpression1);
        PopDependencyExpDes (&DepExpressionOpCode->EqualExp.SubExpression2);
        PushDependencyExpDes (&DepExpressionOpCode);
        break;
 
      case EFI_IFR_GREATER_EQUAL_OP:
        DepExpressionOpCode->GreaterEqualExp.Operand = ExpressionOpCode->Operand;
        PopDependencyExpDes (&DepExpressionOpCode->GreaterEqualExp.LeftHandExp);
        PopDependencyExpDes (&DepExpressionOpCode->GreaterEqualExp.RightHandExp);
        PushDependencyExpDes (&DepExpressionOpCode);
        break;
 
      case EFI_IFR_GREATER_THAN_OP:
        DepExpressionOpCode->GreaterThanExp.Operand = ExpressionOpCode->Operand;
        PopDependencyExpDes (&DepExpressionOpCode->GreaterThanExp.LeftHandExp);
        PopDependencyExpDes (&DepExpressionOpCode->GreaterThanExp.RightHandExp);
        PushDependencyExpDes (&DepExpressionOpCode);
        break;
 
      case EFI_IFR_LESS_EQUAL_OP:
        DepExpressionOpCode->LessEqualExp.Operand = ExpressionOpCode->Operand;
        PopDependencyExpDes (&DepExpressionOpCode->LessEqualExp.LeftHandExp);
        PopDependencyExpDes (&DepExpressionOpCode->LessEqualExp.RightHandExp);
        PushDependencyExpDes (&DepExpressionOpCode);
        break;
 
      case EFI_IFR_LESS_THAN_OP:
        DepExpressionOpCode->LessThanExp.Operand = ExpressionOpCode->Operand;
        PopDependencyExpDes (&DepExpressionOpCode->LessThanExp.LeftHandExp);
        PopDependencyExpDes (&DepExpressionOpCode->LessThanExp.RightHandExp);
        PushDependencyExpDes (&DepExpressionOpCode);
        break;
 
      case EFI_IFR_MATCH_OP:
        DepExpressionOpCode->MatchExp.Operand = ExpressionOpCode->Operand;
        PopDependencyExpDes (&DepExpressionOpCode->MatchExp.PatternExp);
        PopDependencyExpDes (&DepExpressionOpCode->MatchExp.StringExp);
        PushDependencyExpDes (&DepExpressionOpCode);
        break;
 
      case EFI_IFR_MATCH2_OP:
        DepExpressionOpCode->Match2Exp.Operand = ExpressionOpCode->Operand;
        CopyMem (&DepExpressionOpCode->Match2Exp.SyntaxType, &ExpressionOpCode->ExtraData.Guid, sizeof (EFI_GUID));
        PopDependencyExpDes (&DepExpressionOpCode->Match2Exp.PatternExp);
        PopDependencyExpDes (&DepExpressionOpCode->Match2Exp.StringExp);
        PushDependencyExpDes (&DepExpressionOpCode);
        break;
 
      case EFI_IFR_MODULO_OP:
        DepExpressionOpCode->ModExp.Operand = ExpressionOpCode->Operand;
        PopDependencyExpDes (&DepExpressionOpCode->ModExp.LeftHandExp);
        PopDependencyExpDes (&DepExpressionOpCode->ModExp.RightHandExp);
        PushDependencyExpDes (&DepExpressionOpCode);
        break;
 
      case EFI_IFR_MULTIPLY_OP:
        DepExpressionOpCode->MultExp.Operand = ExpressionOpCode->Operand;
        PopDependencyExpDes (&DepExpressionOpCode->MultExp.LeftHandExp);
        PopDependencyExpDes (&DepExpressionOpCode->MultExp.RightHandExp);
        PushDependencyExpDes (&DepExpressionOpCode);
        break;
 
      case EFI_IFR_NOT_EQUAL_OP:
        DepExpressionOpCode->NotEqualExp.Operand = ExpressionOpCode->Operand;
        PopDependencyExpDes (&DepExpressionOpCode->NotEqualExp.SubExpression1);
        PopDependencyExpDes (&DepExpressionOpCode->NotEqualExp.SubExpression2);
        PushDependencyExpDes (&DepExpressionOpCode);
        break;
 
      case EFI_IFR_OR_OP:
        DepExpressionOpCode->OrExp.Operand = ExpressionOpCode->Operand;
        PopDependencyExpDes (&DepExpressionOpCode->OrExp.SubExpression1);
        PopDependencyExpDes (&DepExpressionOpCode->OrExp.SubExpression2);
        PushDependencyExpDes (&DepExpressionOpCode);
        break;
 
      case EFI_IFR_SHIFT_LEFT_OP:
        DepExpressionOpCode->ShiftLeftExp.Operand = ExpressionOpCode->Operand;
        PopDependencyExpDes (&DepExpressionOpCode->ShiftLeftExp.LeftHandExp);
        PopDependencyExpDes (&DepExpressionOpCode->ShiftLeftExp.RightHandExp);
        PushDependencyExpDes (&DepExpressionOpCode);
        break;
 
      case EFI_IFR_SHIFT_RIGHT_OP:
        DepExpressionOpCode->ShiftRightExp.Operand = ExpressionOpCode->Operand;
        PopDependencyExpDes (&DepExpressionOpCode->ShiftRightExp.LeftHandExp);
        PopDependencyExpDes (&DepExpressionOpCode->ShiftRightExp.RightHandExp);
        PushDependencyExpDes (&DepExpressionOpCode);
        break;
 
      case EFI_IFR_SUBTRACT_OP:
        DepExpressionOpCode->SubtractExp.Operand = ExpressionOpCode->Operand;
        PopDependencyExpDes (&DepExpressionOpCode->SubtractExp.LeftHandExp);
        PopDependencyExpDes (&DepExpressionOpCode->SubtractExp.RightHandExp);
        PushDependencyExpDes (&DepExpressionOpCode);
        break;
 
      //
      // ternary-op
      //
      case EFI_IFR_CONDITIONAL_OP:
        DepExpressionOpCode->ConditionalExp.Operand = ExpressionOpCode->Operand;
        PopDependencyExpDes (&DepExpressionOpCode->ConditionalExp.CondTrueValExp);
        PopDependencyExpDes (&DepExpressionOpCode->ConditionalExp.CondFalseValExp);
        PopDependencyExpDes (&DepExpressionOpCode->ConditionalExp.ConditionExp);
        PushDependencyExpDes (&DepExpressionOpCode);
        break;
 
      case EFI_IFR_FIND_OP:
        DepExpressionOpCode->FindExp.Operand = ExpressionOpCode->Operand;
        PopDependencyExpDes (&DepExpressionOpCode->FindExp.StringToSearchExp);
        PopDependencyExpDes (&DepExpressionOpCode->FindExp.StringToCompWithExp);
        PopDependencyExpDes (&DepExpressionOpCode->FindExp.IndexExp);
        PushDependencyExpDes (&DepExpressionOpCode);
        break;
 
      case EFI_IFR_MID_OP:
        DepExpressionOpCode->MidExp.Operand = ExpressionOpCode->Operand;
        PopDependencyExpDes (&DepExpressionOpCode->MidExp.StringOrBufferExp);
        PopDependencyExpDes (&DepExpressionOpCode->MidExp.IndexExp);
        PopDependencyExpDes (&DepExpressionOpCode->MidExp.LengthExp);
        PushDependencyExpDes (&DepExpressionOpCode);
        break;
 
      case EFI_IFR_TOKEN_OP:
        DepExpressionOpCode->TokenExp.Operand = ExpressionOpCode->Operand;
        PopDependencyExpDes (&DepExpressionOpCode->TokenExp.StringToSearchExp);
        PopDependencyExpDes (&DepExpressionOpCode->TokenExp.DelimiterExp);
        PopDependencyExpDes (&DepExpressionOpCode->TokenExp.IndexExp);
        PushDependencyExpDes (&DepExpressionOpCode);
        break;
 
      case EFI_IFR_SPAN_OP:
        DepExpressionOpCode->SpanExp.Operand = ExpressionOpCode->Operand;
        PopDependencyExpDes (&DepExpressionOpCode->SpanExp.StringToSearchExp);
        PopDependencyExpDes (&DepExpressionOpCode->SpanExp.CharsetExp);
        PopDependencyExpDes (&DepExpressionOpCode->SpanExp.IndexExp);
        PushDependencyExpDes (&DepExpressionOpCode);
        break;
 
      //
      // Map
      //
      case EFI_IFR_MAP_OP:
        //
        // Go through map expression list.
        //
        DepExpressionOpCode->MapExp.Operand = ExpressionOpCode->Operand;
        MapPairCount                        = 0;
        SubExpressionLink                   = GetFirstNode (&ExpressionOpCode->MapExpressionList);
        while (!IsNull (&ExpressionOpCode->MapExpressionList, SubExpressionLink)) {
          MapPairCount++;
          SubExpressionLink = GetNextNode (&ExpressionOpCode->MapExpressionList, SubExpressionLink);
          if (IsNull (&ExpressionOpCode->MapExpressionList, SubExpressionLink)) {
            Status = EFI_INVALID_PARAMETER;
            goto Done;
          }
 
          //
          // Goto the first expression on next pair.
          //
          SubExpressionLink = GetNextNode (&ExpressionOpCode->MapExpressionList, SubExpressionLink);
        }
 
        DepExpressionOpCode->MapExp.ExpPair = (HII_DEPENDENCY_EXPRESSION_PAIR *)AllocateZeroPool (
                                                                                  MapPairCount * sizeof (HII_DEPENDENCY_EXPRESSION_PAIR)
                                                                                  );
        if (DepExpressionOpCode->MapExp.ExpPair == NULL) {
          Status = EFI_OUT_OF_RESOURCES;
          goto Done;
        }
 
        DepExpressionOpCode->MapExp.ExpPairNo = MapPairCount;
        MapPairCount                          = 0;
        PopDependencyExpDes (&DepExpressionOpCode->MapExp.SubExp);
 
        //
        // Go through map expression list.
        //
        SubExpressionLink = GetFirstNode (&ExpressionOpCode->MapExpressionList);
        while (!IsNull (&ExpressionOpCode->MapExpressionList, SubExpressionLink)) {
          SubExpression = HII_EXPRESSION_FROM_LINK (SubExpressionLink);
          //
          // Get the first expression description in this pair.
          //
          GetHiiExpressionDependency (SubExpression);
          DepExpressionOpCode->MapExp.ExpPair[MapPairCount].MatchExp = SubExpression->RootDependencyExp;
 
          //
          // Get the second expression description in this pair.
          //
          SubExpressionLink = GetNextNode (&ExpressionOpCode->MapExpressionList, SubExpressionLink);
          SubExpression     = HII_EXPRESSION_FROM_LINK (SubExpressionLink);
          GetHiiExpressionDependency (SubExpression);
          DepExpressionOpCode->MapExp.ExpPair[MapPairCount].ReturnExp = SubExpression->RootDependencyExp;
          //
          // Goto the first expression on next pair.
          //
          SubExpressionLink = GetNextNode (&ExpressionOpCode->MapExpressionList, SubExpressionLink);
          MapPairCount++;
        }
 
        PushDependencyExpDes (&DepExpressionOpCode);
        break;
 
      default:
        break;
    }
  }
 
  PopDependencyExpDes (&Expression->RootDependencyExp);
 
Done:
  return Status;
}
 
EXPRESS_RESULT
EvaluateExpressionList (
  IN HII_EXPRESSION_LIST  *ExpList,
  IN BOOLEAN              Evaluate,
  IN HII_FORMSET          *FormSet  OPTIONAL,
  IN HII_FORM             *Form OPTIONAL
  )
{
  UINTN           Index;
  EXPRESS_RESULT  ReturnVal;
  EXPRESS_RESULT  CompareOne;
  EFI_STATUS      Status;
 
  if (ExpList == NULL) {
    return ExpressFalse;
  }
 
  ASSERT (ExpList->Signature == HII_EXPRESSION_LIST_SIGNATURE);
  Index = 0;
 
  //
  // Check whether need to evaluate the expression first.
  //
  if (Evaluate) {
    while (ExpList->Count > Index) {
      Status = EvaluateHiiExpression (FormSet, Form, ExpList->Expression[Index++]);
      if (EFI_ERROR (Status)) {
        return ExpressFalse;
      }
    }
  }
 
  //
  // Run the list of expressions.
  //
  ReturnVal = ExpressFalse;
  for (Index = 0; Index < ExpList->Count; Index++) {
    if (IsHiiValueTrue (&ExpList->Expression[Index]->Result)) {
      switch (ExpList->Expression[Index]->Type) {
        case EFI_HII_EXPRESSION_SUPPRESS_IF:
          CompareOne = ExpressSuppress;
          break;
 
        case EFI_HII_EXPRESSION_GRAY_OUT_IF:
          CompareOne = ExpressGrayOut;
          break;
 
        case EFI_HII_EXPRESSION_DISABLE_IF:
          CompareOne = ExpressDisable;
          break;
 
        default:
          return ExpressFalse;
      }
 
      ReturnVal = ReturnVal < CompareOne ? CompareOne : ReturnVal;
    }
  }
 
  return ReturnVal;
}