boolean.c

来自「EFI BIOS是Intel提出的下一代的BIOS标准。这里上传的Edk源代码是」· C语言 代码 · 共 1,337 行 · 第 1/3 页

  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, &MapBuffer);
      ExtractNvValue (FileFormTags, (*PIterator)->VariableNumber2, Width, (*PIterator)->QuestionId2, &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:

      ValueToString (VariableName, FALSE, (*PIterator)->QuestionId1);

      SizeOfVariable = 0;

      ExtractRequestedNvMap (FileFormTags, (*PIterator)->VariableNumber, &VariableDefinition);

      Status = BooleanVariableWorker (
                VariableName,
                VariableDefinition,
                *StackPtr,
                &SizeOfVariable,
                &VariableData
                );

      if (!EFI_ERROR (Status)) {
        if (SizeOfVariable == 1) {
          EfiCopyMem (&MapValue, VariableData, 1);
        } else {
          EfiCopyMem (&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, &MapBuffer);
      ExtractNvValue (FileFormTags, Iterator->VariableNumber2, Width, Iterator->QuestionId2, &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;
      }

      ValueToString (VariableName, FALSE, Iterator->QuestionId1);

      SizeOfVariable = 0;

      ExtractRequestedNvMap (FileFormTags, Iterator->VariableNumber, &VariableDefinition);

      Status = BooleanVariableWorker (
                VariableName,
                VariableDefinition,
                StackPtr,
                &SizeOfVariable,
                &VariableData
                );

      if (!EFI_ERROR (Status)) {
        if (SizeOfVariable == 1) {
          EfiCopyMem (&MapValue, VariableData, 1);
        } else {
          EfiCopyMem (&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, &MapBuffer);