/*++

Copyright (c) 2006, 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:

  Boolean.c

Abstract:

  This routine will evaluate the IFR inconsistency data to determine if
  something is a valid entry for a particular expression

--*/

#include "Setup.h"
#include "Ui.h"

//
// Global stack used to evaluate boolean expresions
//
BOOLEAN *mBooleanEvaluationStack    = (BOOLEAN) 0;
BOOLEAN *mBooleanEvaluationStackEnd = (BOOLEAN) 0;

STATIC
VOID
GrowBooleanStack (
  IN OUT BOOLEAN  **Stack,
  IN     UINTN    StackSizeInBoolean
  )
/*++

Routine Description:

  Grow size of the boolean stack

Arguments:

  Stack     - Old stack on the way in and new stack on the way out

  StackSizeInBoolean - New size of the stack

Returns:

  NONE 

--*/
{
  BOOLEAN *NewStack;

  NewStack = AllocatePool (StackSizeInBoolean * sizeof (BOOLEAN));
  ASSERT (NewStack != NULL);

  if (*Stack != NULL) {
    //
    // Copy to Old Stack to the New Stack
    //
    CopyMem (
      NewStack,
      mBooleanEvaluationStack,
      (mBooleanEvaluationStackEnd - mBooleanEvaluationStack) * sizeof (BOOLEAN)
      );

    //
    // Make the Stack pointer point to the old data in the new stack
    //
    *Stack = NewStack + (*Stack - mBooleanEvaluationStack);

    //
    // Free The Old Stack
    //
    gBS->FreePool (mBooleanEvaluationStack);
  }

  mBooleanEvaluationStack     = NewStack;
  mBooleanEvaluationStackEnd  = NewStack + StackSizeInBoolean;
}

VOID
InitializeBooleanEvaluator (
  VOID
  )
/*++

Routine Description:

  Allocate a global stack for boolean processing.

Arguments:

  NONE 

Returns:

  NONE 

--*/
{
  BOOLEAN *NullStack;

  NullStack = NULL;
  GrowBooleanStack (&NullStack, 0x1000);
}

STATIC
VOID
PushBool (
  IN OUT BOOLEAN  **Stack,
  IN BOOLEAN      BoolResult
  )
/*++

Routine Description:

  Push an element onto the Boolean Stack

Arguments:

  Stack      - Current stack location.
  BoolResult - BOOLEAN to push.

Returns:

  None.

--*/
{
  CopyMem (*Stack, &BoolResult, sizeof (BOOLEAN));
  *Stack += 1;

  if (*Stack >= mBooleanEvaluationStackEnd) {
    //
    // If we run out of stack space make a new one that is 2X as big. Copy
    // the old data into the new stack and update Stack to point to the old
    // data in the new stack.
    //
    GrowBooleanStack (
      Stack,
      (mBooleanEvaluationStackEnd - mBooleanEvaluationStack) * sizeof (BOOLEAN) * 2
      );
  }
}

STATIC
BOOLEAN
PopBool (
  IN OUT BOOLEAN **Stack
  )
/*++

Routine Description:

  Pop an element from the Boolean stack.

Arguments:

  Stack - Current stack location

Returns:

  Top of the BOOLEAN stack.

--*/
{
  BOOLEAN ReturnValue;

  *Stack -= 1;
  CopyMem (&ReturnValue, *Stack, sizeof (BOOLEAN));
  return ReturnValue;
}

EFI_STATUS
GrowBooleanExpression (
  IN      EFI_INCONSISTENCY_DATA  *InconsistentTags,
  OUT     VOID                    **BooleanExpression,
  IN OUT  UINTN                   *BooleanExpressionLength
  )
{
  UINT8 *NewExpression;

  NewExpression = AllocatePool (*BooleanExpressionLength + sizeof (EFI_INCONSISTENCY_DATA));
  ASSERT (NewExpression != NULL);

  if (*BooleanExpression != NULL) {
    //
    // Copy Old buffer to the New buffer
    //
    CopyMem (NewExpression, *BooleanExpression, *BooleanExpressionLength);

    CopyMem (&NewExpression[*BooleanExpressionLength], InconsistentTags, sizeof (EFI_INCONSISTENCY_DATA));

    //
    // Free The Old buffer
    //
    gBS->FreePool (*BooleanExpression);
  } else {
    //
    // Copy data into new buffer
    //
    CopyMem (NewExpression, InconsistentTags, sizeof (EFI_INCONSISTENCY_DATA));
  }

  *BooleanExpressionLength  = *BooleanExpressionLength + sizeof (EFI_INCONSISTENCY_DATA);
  *BooleanExpression        = (VOID *) NewExpression;
  return EFI_SUCCESS;
}

VOID
CreateBooleanExpression (
  IN  EFI_FILE_FORM_TAGS    *FileFormTags,
  IN  UINT16                Value,
  IN  UINT16                Id,
  IN  BOOLEAN               Complex,
  OUT VOID                  **BooleanExpression,
  OUT UINTN                 *BooleanExpressionLength
  )
/*++

Routine Description:

Arguments:

Returns:

--*/
{
  UINTN                   Count;
  EFI_INCONSISTENCY_DATA  *InconsistentTags;
  EFI_INCONSISTENCY_DATA  FakeInconsistentTags;

  InconsistentTags = FileFormTags->InconsistentTags;

  //
  // Did we run into a question that contains the Id we are looking for?
  //
  for (Count = 0; InconsistentTags->Operand != 0xFF; Count++) {

    //
    // Reserve INVALID_OFFSET_VALUE - 1 for TURE and FALSE, because we need to treat them as well
    // as ideqid etc. but they have no coresponding id, so we reserve this value.
    //
    if (InconsistentTags->QuestionId1 == Id ||
        InconsistentTags->QuestionId1 == INVALID_OFFSET_VALUE - 1) {
      //
      // If !Complex - means evaluate a single if/endif expression
      //
      if (!Complex) {
        //
        // If the ConsistencyId does not match the expression we are looking for
        // skip to the next consistency database entry
        //
        if (InconsistentTags->ConsistencyId != Value) {
          goto NextEntry;
        }
      }
      //
      // We need to rewind to the beginning of the Inconsistent expression
      //
      for (;
           (InconsistentTags->Operand != EFI_IFR_INCONSISTENT_IF_OP) &&
             (InconsistentTags->Operand != EFI_IFR_GRAYOUT_IF_OP) &&
             (InconsistentTags->Operand != EFI_IFR_SUPPRESS_IF_OP);
              ) {
        InconsistentTags = InconsistentTags->Previous;
      }
      //
      // Store the consistency check expression, ensure the next for loop starts at the op-code afterwards
      //
      GrowBooleanExpression (InconsistentTags, BooleanExpression, BooleanExpressionLength);
      InconsistentTags = InconsistentTags->Next;

      //
      // Keep growing until we hit the End expression op-code or we hit the beginning of another
      // consistency check like grayout/suppress
      //
      for (;
           InconsistentTags->Operand != EFI_IFR_END_IF_OP &&
           InconsistentTags->Operand != EFI_IFR_GRAYOUT_IF_OP &&
           InconsistentTags->Operand != EFI_IFR_SUPPRESS_IF_OP;
            ) {
        GrowBooleanExpression (InconsistentTags, BooleanExpression, BooleanExpressionLength);
        InconsistentTags = InconsistentTags->Next;
      }
      //
      // Store the EndExpression Op-code
      //
      GrowBooleanExpression (InconsistentTags, BooleanExpression, BooleanExpressionLength);
    }

NextEntry:
    if (InconsistentTags->Next != NULL) {
      //
      // Skip to next entry
      //
      InconsistentTags = InconsistentTags->Next;
    }
  }

  FakeInconsistentTags.Operand = 0;

  //
  // Add one last expression which will signify we have definitely hit the end
  //
  GrowBooleanExpression (&FakeInconsistentTags, BooleanExpression, BooleanExpressionLength);
}

EFI_STATUS
BooleanVariableWorker (
  IN     CHAR16                   *VariableName,
  IN     EFI_VARIABLE_DEFINITION  *VariableDefinition,
  IN     BOOLEAN                  *StackPtr,
  IN OUT UINTN                    *SizeOfVariable,
  IN OUT VOID                     **VariableData
  )
/*++

Routine Description:


Arguments:

Returns:

--*/
{
  EFI_STATUS  Status;

  Status = gRT->GetVariable (
                  VariableName,
                  &VariableDefinition->Guid,
                  NULL,
                  SizeOfVariable,
                  *VariableData
                  );

  if (EFI_ERROR (Status)) {

    if (Status == EFI_BUFFER_TOO_SMALL) {
      *VariableData = AllocatePool (*SizeOfVariable);
      ASSERT (*VariableData != NULL);

      Status = gRT->GetVariable (
                      VariableName,
                      &VariableDefinition->Guid,
                      NULL,
                      SizeOfVariable,
                      *VariableData
                      );
    }

    if (Status == EFI_NOT_FOUND) {
      //
      // This is a serious flaw, we must have some standard result if a variable
      // is not found.  Our default behavior must either be return a TRUE or FALSE
      // since there is nothing else we can really do.  Therefore, my crystal ball
      // says I will return a FALSE
      //
      PushBool (&StackPtr, FALSE);
    }
  }

  return Status;
}

UINT8
PredicateIfrType (
  IN  EFI_INCONSISTENCY_DATA      *Iterator
  )
/*++

Routine Description:
  This routine is for the purpose of predicate whether the Ifr is generated by a VfrCompiler greater than or equal to 1.88 or
  less than 1.88 which is legacy.

Arguments:
  Iterator    - The pointer to inconsistency tags

Returns:

  0x2         - If IFR is not legacy

  0x1         - If IFR is legacy

--*/
{
  //
  // legacy Ifr cover the states:
  // Not ...
  // Operand Opcode Operand
  //
  // while Operand means ideqval, TRUE, or other what can be evaluated to True or False,
  // and Opcode means AND or OR.
  //
  if (Iterator->Operand == EFI_IFR_NOT_OP   ||
      Iterator->Operand == 0) {
    return 0x1;
  } else if (Iterator->Operand == EFI_IFR_EQ_VAR_VAL_OP ||
             Iterator->Operand == EFI_IFR_EQ_ID_VAL_OP  ||
             Iterator->Operand == EFI_IFR_EQ_ID_ID_OP   ||
             Iterator->Operand == EFI_IFR_EQ_ID_LIST_OP) {
    Iterator++;
    if (Iterator->Operand == EFI_IFR_AND_OP ||
        Iterator->Operand == EFI_IFR_OR_OP) {
      Iterator--;
      return 0x1;
    }
    Iterator--;
  }
  return 0x2;
}

VOID
PostOrderEvaluate (
  IN      EFI_FILE_FORM_TAGS          *FileFormTags,
  IN      UINT16                      Width,
  IN OUT  EFI_INCONSISTENCY_DATA      **PIterator,
  IN OUT  BOOLEAN                     **StackPtr
  )
/*++

Routine Description:
  PostOrderEvaluate is used for Ifr generated by VfrCompiler greater than or equal to 1.88,
  which generate Operand Operand Opcode type Ifr.
  PostOrderEvaluete only evaluate boolean expression part, not suppressif/grayoutif. TRUE,
  FALSE, >=, >, (, ) are supported.

Arguments:

  FileFormTags     - The pointer to the tags of the form

  Width            - Width of Operand, recognized every iteration

  PIterator        - The pointer to inconsistency tags

  StackPtr         - The pointer to the evaluation stack

Returns:

  TRUE             - If value is valid

  FALSE            - If value is not valid

--*/
{
  BOOLEAN                 Operator;
  BOOLEAN                 Operator2;
  UINT16                  *MapBuffer;
  UINT16                  *MapBuffer2;
  UINT16                  MapValue;
  UINT16                  MapValue2;
  UINTN                   SizeOfVariable;
  CHAR16                  VariableName[40];
  VOID                    *VariableData;
  EFI_VARIABLE_DEFINITION *VariableDefinition;
  EFI_STATUS              Status;
  UINTN                   Index;
  BOOLEAN                 PushValue;

  Operator        = FALSE;
  Operator2       = FALSE;
  MapBuffer       = NULL;
  MapBuffer2      = NULL;
  MapValue        = 0;
  MapValue2       = 0;
  VariableData    = NULL;

  while (TRUE) {
    if ((*PIterator)->Operand == 0) {
      return;
    }

    Width = (*PIterator)->Width;

    // 
    //  Because INVALID_OFFSET_VALUE - 1 is reserved for TRUE or FALSE, omit them.
    //
    if ((*PIterator)->QuestionId1 != INVALID_OFFSET_VALUE &&
        (*PIterator)->QuestionId1 != INVALID_OFFSET_VALUE - 1) {
      ExtractNvValue (FileFormTags, (*PIterator)->VariableNumber, Width, (*PIterator)->QuestionId1, (VOID **) &MapBuffer);
      ExtractNvValue (FileFormTags, (*PIterator)->VariableNumber2, Width, (*PIterator)->QuestionId2, (VOID **) &MapBuffer2);
      if (MapBuffer != NULL) {
        if (Width == 2) {
          MapValue = *MapBuffer;
        } else {
          MapValue = (UINT8) *MapBuffer;
        }

        gBS->FreePool (MapBuffer);
      }

      if (MapBuffer2 != NULL) {
        if (Width == 2) {
          MapValue2 = *MapBuffer2;
        } else {
          MapValue2 = (UINT8) *MapBuffer2;
        }

        gBS->FreePool (MapBuffer2);
      }
    }

    switch ((*PIterator)->Operand) {
    case EFI_IFR_EQ_VAR_VAL_OP:
      UnicodeValueToString (
        VariableName, 
        FALSE, 
        (UINTN) (*PIterator)->QuestionId1, 
        (sizeof (VariableName) / sizeof (VariableName[0]))
        );

      SizeOfVariable = 0;

      ExtractRequestedNvMap (FileFormTags, (*PIterator)->VariableNumber, &VariableDefinition);

      Status = BooleanVariableWorker (
                VariableName,
                VariableDefinition,
                *StackPtr,
                &SizeOfVariable,
                &VariableData
                );

      if (!EFI_ERROR (Status)) {
        if (SizeOfVariable == 1) {
          CopyMem (&MapValue, VariableData, 1);
        } else {
          CopyMem (&MapValue, VariableData, 2);
        }

        //
        // Do operation after knowing the compare operator.
        //
        MapValue2 = (*PIterator)->Value;
        (*PIterator)++;
        if ((*PIterator)->Operand == EFI_IFR_GT_OP) {
          PushValue = (BOOLEAN) (MapValue > MapValue2);
        } else if ((*PIterator)->Operand == EFI_IFR_GE_OP) {
          PushValue = (BOOLEAN) (MapValue >= MapValue2);
        } else {
          (*PIterator)--;
          PushValue = (BOOLEAN) (MapValue == MapValue2);
        }
        PushBool (StackPtr, PushValue);
      }

      break;

    case EFI_IFR_EQ_ID_VAL_OP:
      //
      // Do operation after knowing the compare operator.
      //
      MapValue2 = (*PIterator)->Value;
      (*PIterator)++;
      if ((*PIterator)->Operand == EFI_IFR_GT_OP) {
        PushValue = (BOOLEAN) (MapValue > MapValue2);
      } else if ((*PIterator)->Operand == EFI_IFR_GE_OP) {
        PushValue = (BOOLEAN) (MapValue >= MapValue2);
      } else {
        (*PIterator)--;
        PushValue = (BOOLEAN) (MapValue == MapValue2);
      }
      PushBool (StackPtr, PushValue);
      break;

    case EFI_IFR_EQ_ID_ID_OP:
      //
      // Do operation after knowing the compare operator.
      //
      (*PIterator)++;
      if ((*PIterator)->Operand == EFI_IFR_GT_OP) {
        PushValue = (BOOLEAN) (MapValue > MapValue2);
      } else if ((*PIterator)->Operand == EFI_IFR_GE_OP) {
        PushValue = (BOOLEAN) (MapValue >= MapValue2);
      } else {
        (*PIterator)--;
        PushValue = (BOOLEAN) (MapValue == MapValue2);
      }
      PushBool (StackPtr, PushValue);
      break;

    case EFI_IFR_EQ_ID_LIST_OP:
      for (Index = 0; Index < (*PIterator)->ListLength; Index++) {
        Operator = (BOOLEAN) (MapValue == (*PIterator)->ValueList[Index]);
        if (Operator) {
          break;
        }
      }

      PushBool (StackPtr, Operator);
      break;

    case EFI_IFR_TRUE_OP:
      PushBool (StackPtr, TRUE);
      break;

    case EFI_IFR_FALSE_OP:
      PushBool (StackPtr, FALSE);
      break;

    case EFI_IFR_AND_OP:
      Operator  = PopBool (StackPtr);
      Operator2 = PopBool (StackPtr);
      PushBool (StackPtr, (BOOLEAN) (Operator && Operator2));
      break;
    case EFI_IFR_OR_OP:
      Operator  = PopBool (StackPtr);
      Operator2 = PopBool (StackPtr);
      PushBool (StackPtr, (BOOLEAN) (Operator || Operator2));
      break;
    case EFI_IFR_NOT_OP:
      Operator  = PopBool (StackPtr);
      PushBool (StackPtr, !Operator);
      break;

    case EFI_IFR_SUPPRESS_IF_OP:
    case EFI_IFR_GRAYOUT_IF_OP:
    case EFI_IFR_INCONSISTENT_IF_OP:
    default:
      //
      // Return to the previous tag if runs out of boolean expression.
      //
      (*PIterator)--;
      return;
    }
    (*PIterator)++;
  }
}

BOOLEAN
ValueIsNotValid (
  IN  BOOLEAN                     Complex,
  IN  UINT16                      Value,
  IN  EFI_TAG                     *Tag,
  IN  EFI_FILE_FORM_TAGS          *FileFormTags,
  IN  STRING_REF                  *PopUp
  )
/*++

Routine Description:


Arguments:

Returns:

  TRUE - If value is valid

  FALSE - If value is not valid

--*/
{
  BOOLEAN                 *StackPtr;
  EFI_INCONSISTENCY_DATA  *Iterator;
  BOOLEAN                 Operator;
  BOOLEAN                 Operator2;
  UINTN                   Index;
  VOID                    *BooleanExpression;
  UINTN                   BooleanExpressionLength;
  BOOLEAN                 NotOperator;
  BOOLEAN                 OrOperator;
  BOOLEAN                 AndOperator;
  BOOLEAN                 ArtificialEnd;
  UINT16                  *MapBuffer;
  UINT16                  *MapBuffer2;
  UINT16                  MapValue;
  UINT16                  MapValue2;
  UINTN                   SizeOfVariable;
  CHAR16                  VariableName[40];
  VOID                    *VariableData;
  EFI_STATUS              Status;
  UINT16                  Id;
  UINT16                  Width;
  EFI_VARIABLE_DEFINITION *VariableDefinition;
  BOOLEAN                 CosmeticConsistency;
  UINT8                   IsLegacy;

  VariableData            = NULL;
  BooleanExpressionLength = 0;
  BooleanExpression       = NULL;
  Operator                = FALSE;
  ArtificialEnd           = FALSE;
  CosmeticConsistency     = TRUE;
  IsLegacy                = 0;

  Id                      = Tag->Id;
  if (Tag->StorageWidth == 1) {
    Width = 1;
  } else {
    Width = 2;
  }
  CreateBooleanExpression (FileFormTags, Value, Id, Complex, &BooleanExpression, &BooleanExpressionLength);

  if (mBooleanEvaluationStack == 0) {
    InitializeBooleanEvaluator ();
  }

  if (BooleanExpression == NULL) {
    return FALSE;
  }

  StackPtr    = mBooleanEvaluationStack;
  Iterator    = BooleanExpression;
  MapBuffer   = NULL;
  MapBuffer2  = NULL;
  MapValue    = 0;
  MapValue2   = 0;

  while (TRUE) {
    NotOperator = FALSE;
    OrOperator  = FALSE;
    AndOperator = FALSE;

    if (Iterator->Operand == 0) {
      return Operator;
    }

    // 
    //  Because INVALID_OFFSET_VALUE - 1 is reserved for TRUE or FALSE, omit them.
    //
    if (Iterator->QuestionId1 != INVALID_OFFSET_VALUE &&
        Iterator->QuestionId1 != INVALID_OFFSET_VALUE-1) {
      ExtractNvValue (FileFormTags, Iterator->VariableNumber, Width, Iterator->QuestionId1, (VOID **) &MapBuffer);
      ExtractNvValue (FileFormTags, Iterator->VariableNumber2, Width, Iterator->QuestionId2, (VOID **) &MapBuffer2);
      if (MapBuffer != NULL) {
        if (Width == 2) {
          MapValue = *MapBuffer;
        } else {
          MapValue = (UINT8) *MapBuffer;
        }

        gBS->FreePool (MapBuffer);
      }

      if (MapBuffer2 != NULL) {
        if (Width == 2) {
          MapValue2 = *MapBuffer2;
        } else {
          MapValue2 = (UINT8) *MapBuffer2;
        }

        gBS->FreePool (MapBuffer2);
      }
    }

    switch (Iterator->Operand) {
    case EFI_IFR_SUPPRESS_IF_OP:
      //
      // Must have hit a suppress followed by a grayout or vice-versa
      //
      if (ArtificialEnd) {
        ArtificialEnd = FALSE;
        Operator      = PopBool (&StackPtr);
        if (Operator) {
          Tag->Suppress = TRUE;
        }

        return Operator;
      }

      ArtificialEnd = TRUE;
      *PopUp        = Iterator->Popup;
      break;

    case EFI_IFR_GRAYOUT_IF_OP:
      //
      // Must have hit a suppress followed by a grayout or vice-versa
      //
      if (ArtificialEnd) {
        ArtificialEnd = FALSE;
        Operator      = PopBool (&StackPtr);
        if (Operator) {
          Tag->GrayOut = TRUE;
        }

        return Operator;
      }

      ArtificialEnd = TRUE;
      *PopUp        = Iterator->Popup;
      break;

    case EFI_IFR_INCONSISTENT_IF_OP:
      CosmeticConsistency = FALSE;
      *PopUp              = Iterator->Popup;
      break;

    //
    // In the case of external variable values, we must read the variable which is
    // named by the human readable version of the OpCode->VariableId and the guid of the formset
    //
    case EFI_IFR_EQ_VAR_VAL_OP:
      //
      // To check whether Ifr is legacy. Once every boolean expression.
      //
      if (IsLegacy == 0) {
        IsLegacy = PredicateIfrType (Iterator);
      }
      if (IsLegacy == 0x2) {
        PostOrderEvaluate (FileFormTags, Width, &Iterator, &StackPtr);
        break;
      }

      UnicodeValueToString (
        VariableName, 
        FALSE, 
        (UINTN) Iterator->QuestionId1, 
        (sizeof (VariableName) / sizeof (VariableName[0]))
        );

      SizeOfVariable = 0;

      ExtractRequestedNvMap (FileFormTags, Iterator->VariableNumber, &VariableDefinition);

      Status = BooleanVariableWorker (
                VariableName,
                VariableDefinition,
                StackPtr,
                &SizeOfVariable,
                &VariableData
                );

      if (!EFI_ERROR (Status)) {
        if (SizeOfVariable == 1) {
          CopyMem (&MapValue, VariableData, 1);
        } else {
          CopyMem (&MapValue, VariableData, 2);
        }

        PushBool (&StackPtr, (BOOLEAN) (MapValue == Iterator->Value));
      }

      break;

    case EFI_IFR_EQ_ID_VAL_OP:
      //
      // To check whether Ifr is legacy. Once every boolean expression.
      //
      if (IsLegacy == 0) {
        IsLegacy = PredicateIfrType (Iterator);
      }
      if (IsLegacy == 0x2) {
        PostOrderEvaluate (FileFormTags, Width, &Iterator, &StackPtr);
        break;
      }

      PushBool (&StackPtr, (BOOLEAN) (MapValue == Iterator->Value));
      break;

    case EFI_IFR_EQ_ID_ID_OP:
      //
      // To check whether Ifr is legacy. Once every boolean expression.
      //
      if (IsLegacy == 0) {
        IsLegacy = PredicateIfrType (Iterator);
      }
      if (IsLegacy == 0x2) {
        PostOrderEvaluate (FileFormTags, Width, &Iterator, &StackPtr);
        break;
      }

      PushBool (&StackPtr, (BOOLEAN) (MapValue == MapValue2));
      break;

    case EFI_IFR_EQ_ID_LIST_OP:
      //
      // To check whether Ifr is legacy. Once every boolean expression.
      //
      if (IsLegacy == 0) {
        IsLegacy = PredicateIfrType (Iterator);
      }
      if (IsLegacy == 0x2) {
        PostOrderEvaluate (FileFormTags, Width, &Iterator, &StackPtr);
        break;
      }

      for (Index = 0; Index < Iterator->ListLength; Index++) {
        Operator = (BOOLEAN) (MapValue == Iterator->ValueList[Index]);
        if (Operator) {
          break;
        }
      }

      PushBool (&StackPtr, Operator);
      break;

    case EFI_IFR_AND_OP:
      Iterator++;
      if (Iterator->Operand == EFI_IFR_NOT_OP) {
        NotOperator = TRUE;
        Iterator++;
      }

      if (Iterator->QuestionId1 != INVALID_OFFSET_VALUE) {
        ExtractNvValue (FileFormTags, Iterator->VariableNumber, Width, Iterator->QuestionId1, (VOID **) &MapBuffer);
        ExtractNvValue (FileFormTags, Iterator->VariableNumber2, Width, Iterator->QuestionId2, (VOID **) &MapBuffer2);
        if (MapBuffer != NULL) {
          if (Width == 2) {
            MapValue = *MapBuffer;
          } else {
            MapValue = (UINT8) *MapBuffer;
          }

          gBS->FreePool (MapBuffer);
        }

        if (MapBuffer2 != NULL) {
          if (Width == 2) {
            MapValue2 = *MapBuffer2;
          } else {
            MapValue2 = (UINT8) *MapBuffer2;
          }

          gBS->FreePool (MapBuffer2);
        }
      }

      switch (Iterator->Operand) {
      case EFI_IFR_EQ_ID_VAL_OP:
        //
        // If Not - flip the results
        //
        if (NotOperator) {
          Operator = (BOOLEAN)!(MapValue == Iterator->Value);
        } else {
          Operator = (BOOLEAN) (MapValue == Iterator->Value);
        }

        PushBool (&StackPtr, Operator);
        break;

      //
      // In the case of external variable values, we must read the variable which is
      // named by the human readable version of the OpCode->VariableId and the guid of the formset
      //
      case EFI_IFR_EQ_VAR_VAL_OP:
        UnicodeValueToString (
          VariableName, 
          FALSE, 
          (UINTN) Iterator->QuestionId1, 
          (sizeof (VariableName) / sizeof (VariableName[0]))
          );

        SizeOfVariable = 0;

        ExtractRequestedNvMap (FileFormTags, Iterator->VariableNumber, &VariableDefinition);

        Status = BooleanVariableWorker (
                  VariableName,
                  VariableDefinition,
                  StackPtr,
                  &SizeOfVariable,
                  &VariableData
                  );

        if (!EFI_ERROR (Status)) {
          if (SizeOfVariable == 1) {
            CopyMem (&MapValue, VariableData, 1);
          } else {
            CopyMem (&MapValue, VariableData, 2);
          }
          //
          // If Not - flip the results
          //
          if (NotOperator) {
            PushBool (&StackPtr, (BOOLEAN)!(MapValue == Iterator->Value));
          } else {
            PushBool (&StackPtr, (BOOLEAN) (MapValue == Iterator->Value));
          }
        }
        break;

      case EFI_IFR_EQ_ID_ID_OP:
        //
        // If Not - flip the results
        //
        if (NotOperator) {
          Operator = (BOOLEAN)!(MapValue == MapValue2);
        } else {
          Operator = (BOOLEAN) (MapValue == MapValue2);
        }

        PushBool (&StackPtr, Operator);
        break;

      case EFI_IFR_EQ_ID_LIST_OP:
        for (Index = 0; Index < Iterator->ListLength; Index++) {
          //
          // If Not - flip the results
          //
          if (NotOperator) {
            Operator = (BOOLEAN)!(MapValue == Iterator->ValueList[Index]);
          } else {
            Operator = (BOOLEAN) (MapValue == Iterator->ValueList[Index]);
          }
          //
          // If We are trying to make sure that MapValue != Item[x], keep looking through
          // the list to make sure we don't equal any other items
          //
          if (Operator && NotOperator) {
            continue;
          }
          //
          // If MapValue == Item, then we have succeeded (first found is good enough)
          //
          if (Operator) {
            break;
          }
        }

        PushBool (&StackPtr, Operator);
        break;

      default:
        return FALSE;
      }

      Operator  = PopBool (&StackPtr);
      Operator2 = PopBool (&StackPtr);
      PushBool (&StackPtr, (BOOLEAN) (Operator && Operator2));
      break;

    case EFI_IFR_OR_OP:
      Iterator++;
      if (Iterator->Operand == EFI_IFR_NOT_OP) {
        NotOperator = TRUE;
        Iterator++;
      }

      if (Iterator->QuestionId1 != INVALID_OFFSET_VALUE) {
        ExtractNvValue (FileFormTags, Iterator->VariableNumber, Width, Iterator->QuestionId1, (VOID **) &MapBuffer);
        ExtractNvValue (FileFormTags, Iterator->VariableNumber2, Width, Iterator->QuestionId2, (VOID **) &MapBuffer2);
        if (MapBuffer != NULL) {
          if (Width == 2) {
            MapValue = *MapBuffer;
          } else {
            MapValue = (UINT8) *MapBuffer;
          }

          gBS->FreePool (MapBuffer);
        }

        if (MapBuffer2 != NULL) {
          if (Width == 2) {
            MapValue2 = *MapBuffer2;
          } else {
            MapValue2 = (UINT8) *MapBuffer2;
          }

          gBS->FreePool (MapBuffer2);
        }
      }

      switch (Iterator->Operand) {
      case EFI_IFR_EQ_ID_VAL_OP:
        //
        // If Not - flip the results
        //
        if (NotOperator) {
          Operator = (BOOLEAN)!(MapValue == Iterator->Value);
        } else {
          Operator = (BOOLEAN) (MapValue == Iterator->Value);
        }

        PushBool (&StackPtr, Operator);
        break;

      //
      // In the case of external variable values, we must read the variable which is
      // named by the human readable version of the OpCode->VariableId and the guid of the formset
      //
      case EFI_IFR_EQ_VAR_VAL_OP:
        UnicodeValueToString (
          VariableName, 
          FALSE, 
          (UINTN) Iterator->QuestionId1, 
          (sizeof (VariableName) / sizeof (VariableName[0]))
          );

        SizeOfVariable = 0;

        ExtractRequestedNvMap (FileFormTags, Iterator->VariableNumber, &VariableDefinition);

        Status = BooleanVariableWorker (
                  VariableName,
                  VariableDefinition,
                  StackPtr,
                  &SizeOfVariable,
                  &VariableData
                  );

        if (!EFI_ERROR (Status)) {
          if (SizeOfVariable == 1) {
            CopyMem (&MapValue, VariableData, 1);
          } else {
            CopyMem (&MapValue, VariableData, 2);
          }
          //
          // If Not - flip the results
          //
          if (NotOperator) {
            PushBool (&StackPtr, (BOOLEAN)!(MapValue == Iterator->Value));
          } else {
            PushBool (&StackPtr, (BOOLEAN) (MapValue == Iterator->Value));
          }
        }
        break;

      case EFI_IFR_EQ_ID_ID_OP:
        //
        // If Not - flip the results
        //
        if (NotOperator) {
          Operator = (BOOLEAN)!(MapValue == MapValue2);
        } else {
          Operator = (BOOLEAN) (MapValue == MapValue2);
        }

        PushBool (&StackPtr, Operator);
        break;

      case EFI_IFR_EQ_ID_LIST_OP:
        for (Index = 0; Index < Iterator->ListLength; Index++) {
          //
          // If Not - flip the results
          //
          if (NotOperator) {
            Operator = (BOOLEAN)!(MapValue == Iterator->ValueList[Index]);
          } else {
            Operator = (BOOLEAN) (MapValue == Iterator->ValueList[Index]);
          }
          //
          // If We are trying to make sure that MapValue != Item[x], keep looking through
          // the list to make sure we don't equal any other items
          //
          if (Operator && NotOperator) {
            continue;
          }
          //
          // If MapValue == Item, then we have succeeded (first found is good enough)
          //
          if (Operator) {
            break;
          }
        }

        PushBool (&StackPtr, Operator);
        break;

      default:
        return FALSE;
      }

      Operator  = PopBool (&StackPtr);
      Operator2 = PopBool (&StackPtr);
      PushBool (&StackPtr, (BOOLEAN) (Operator || Operator2));
      break;

    case EFI_IFR_NOT_OP:
      //
      // To check whether Ifr is legacy. Once every boolean expression.
      //
      if (IsLegacy == 0) {
        IsLegacy = PredicateIfrType (Iterator);
      }
      if (IsLegacy == 0x2) {
        PostOrderEvaluate (FileFormTags, Width, &Iterator, &StackPtr);
        break;
      }

      //
      // I don't need to set the NotOperator (I know that I have to NOT this in this case
      //
      Iterator++;

      if (Iterator->Operand == EFI_IFR_OR_OP) {
        OrOperator = TRUE;
        Iterator++;
      }

      if (Iterator->Operand == EFI_IFR_AND_OP) {
        AndOperator = TRUE;
        Iterator++;
      }

      if (Iterator->QuestionId1 != INVALID_OFFSET_VALUE) {
        ExtractNvValue (FileFormTags, Iterator->VariableNumber, Width, Iterator->QuestionId1, (VOID **) &MapBuffer);
        ExtractNvValue (FileFormTags, Iterator->VariableNumber2, Width, Iterator->QuestionId2, (VOID **) &MapBuffer2);
        if (MapBuffer != NULL) {
          if (Width == 2) {
            MapValue = *MapBuffer;
          } else {
            MapValue = (UINT8) *MapBuffer;
          }

          gBS->FreePool (MapBuffer);
        }

        if (MapBuffer2 != NULL) {
          if (Width == 2) {
            MapValue2 = *MapBuffer2;
          } else {
            MapValue2 = (UINT8) *MapBuffer2;
          }

          gBS->FreePool (MapBuffer2);
        }
      }

      switch (Iterator->Operand) {
      case EFI_IFR_EQ_ID_VAL_OP:
        Operator = (BOOLEAN)!(MapValue == Iterator->Value);
        PushBool (&StackPtr, Operator);
        break;

      //
      // In the case of external variable values, we must read the variable which is
      // named by the human readable version of the OpCode->VariableId and the guid of the formset
      //
      case EFI_IFR_EQ_VAR_VAL_OP:
        UnicodeValueToString (
          VariableName, 
          FALSE, 
          (UINTN) Iterator->QuestionId1, 
          (sizeof (VariableName) / sizeof (VariableName[0]))
          );

        SizeOfVariable = 0;

        ExtractRequestedNvMap (FileFormTags, Iterator->VariableNumber, &VariableDefinition);

        Status = BooleanVariableWorker (
                  VariableName,
                  VariableDefinition,
                  StackPtr,
                  &SizeOfVariable,
                  &VariableData
                  );

        if (!EFI_ERROR (Status)) {
          if (SizeOfVariable == 1) {
            CopyMem (&MapValue, VariableData, 1);
          } else {
            CopyMem (&MapValue, VariableData, 2);
          }

          PushBool (&StackPtr, (BOOLEAN)!(MapValue == Iterator->Value));
        }
        break;

      case EFI_IFR_EQ_ID_ID_OP:
        Operator = (BOOLEAN)!(MapValue == MapValue2);
        PushBool (&StackPtr, Operator);
        break;

      case EFI_IFR_EQ_ID_LIST_OP:
        for (Index = 0; Index < Iterator->ListLength; Index++) {
          Operator = (BOOLEAN)!(MapValue == Iterator->ValueList[Index]);
          if (Operator) {
            continue;
          }
        }

        PushBool (&StackPtr, Operator);
        break;

      default:
        return FALSE;
      }

      Operator  = PopBool (&StackPtr);
      Operator2 = PopBool (&StackPtr);

      if (OrOperator) {
        PushBool (&StackPtr, (BOOLEAN) (Operator || Operator2));
      }

      if (AndOperator) {
        PushBool (&StackPtr, (BOOLEAN) (Operator && Operator2));
      }

      if (!OrOperator && !AndOperator) {
        PushBool (&StackPtr, Operator);
      }
      break;
    
    case EFI_IFR_TRUE_OP:
      //
      // To check whether Ifr is legacy. Once every boolean expression.
      //
      if (IsLegacy == 0) {
        IsLegacy = PredicateIfrType (Iterator);
      }
      if (IsLegacy == 0x2) {
        PostOrderEvaluate (FileFormTags, Width, &Iterator, &StackPtr);
        break;
      }
      break;

    case EFI_IFR_FALSE_OP:
      //
      // To check whether Ifr is legacy. Once every boolean expression.
      //
      if (IsLegacy == 0) {
        IsLegacy = PredicateIfrType (Iterator);
      }
      if (IsLegacy == 0x2) {
        PostOrderEvaluate (FileFormTags, Width, &Iterator, &StackPtr);
        break;
      }
      break;

    case EFI_IFR_END_IF_OP:
      Operator = PopBool (&StackPtr);
      //
      // If there is an error, return, otherwise keep looking - there might
      // be another test that causes an error
      //
      if (Operator) {
        if (Complex && CosmeticConsistency) {
          return EFI_SUCCESS;
        } else {
          return Operator;
        }
      } else {
        //
        // If not doing a global consistency check, the endif is the REAL terminator of this operation
        // This is used for grayout/suppress operations.  InconsistentIf is a global operation so the EndIf is
        // not the end-all be-all of terminators.
        //
        if (!Complex) {
          return Operator;
        }
        break;
      }

    default:
      //
      // Must have hit a non-consistency related op-code after a suppress/grayout
      //
      if (ArtificialEnd) {
        ArtificialEnd = FALSE;
        Operator      = PopBool (&StackPtr);
        return Operator;
      }

      return FALSE;
    }

    Iterator++;
  }

  return FALSE;
}