processoptions.c

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

    //
    if (StringPtr[CurrIndex] == CHAR_NULL) {
      //
      // Copy the fragment to the FormattedString buffer
      //
      StrnCpy ((FormattedString[0] + StringCount * gHelpBlockWidth), &StringPtr[PrevIndex], CurrIndex - PrevIndex);
      StringCount++;
      break;
    }
    //
    // The premise is that for every HELP_BLOCK_WIDTH we rewind
    // until we find the first space.  That is the delimiter for
    // the string, and we will then advance our CurrIndex another
    // HELP_BLOCK_WIDTH and continue the process breaking the larger
    // string into chunks that fit within the HELP_BLOCK_WIDTH requirements.
    //
    if (StringPtr[CurrIndex] == CHAR_SPACE) {
      //
      // Copy the fragment to the FormattedString buffer
      //
      StrnCpy ((FormattedString[0] + StringCount * gHelpBlockWidth), &StringPtr[PrevIndex], CurrIndex - PrevIndex);
      StringCount++;
      PrevIndex = CurrIndex + 1;
      CurrIndex = CurrIndex + gHelpBlockWidth;
    }
    //
    // Found a LineFeed, advance to the next line.
    //
    if (StringPtr[CurrIndex] == CHAR_LINEFEED) {
      StringPtr[CurrIndex] = CHAR_SPACE;
      //
      // "\n" is represented as CHAR_CARRIAGE_RETURN + CHAR_LINEFEED,check this.
      //
      if (StringPtr[CurrIndex - 1] == CHAR_CARRIAGE_RETURN) {
        StringPtr[CurrIndex - 1] = CHAR_SPACE;
      }

      StrnCpy ((FormattedString[0] + StringCount * gHelpBlockWidth), &StringPtr[PrevIndex], CurrIndex - PrevIndex);
      StringCount++;
      PrevIndex = CurrIndex + 1;
      CurrIndex = CurrIndex + gHelpBlockWidth;
    }
  }
  //
  // endfor
  //
  return ;
}

VOID
IfrToFormTag (
  IN  UINT8               OpCode,
  IN  EFI_TAG             *TargetTag,
  IN  VOID                *FormData,
  EFI_VARIABLE_DEFINITION *VariableDefinitionsHead
  )
{
  UINT16                  TempValue;
  CHAR16                  *VariableName;
  CHAR8                   *AsciiString;
  EFI_VARIABLE_DEFINITION *VariableDefinitions;
  EFI_VARIABLE_DEFINITION *PreviousVariableDefinitions;
  STATIC UINT16           VariableSize;
  EFI_GUID                Guid;
  STATIC UINT16           CurrentVariable;
  STATIC UINT16           CurrentVariable2;
  UINTN                   Index;

  switch (OpCode) {
  case EFI_IFR_FORM_OP:
    EfiCopyMem (&TargetTag->Id, &((EFI_IFR_FORM *) FormData)->FormId, sizeof (UINT16));
    EfiCopyMem (&TargetTag->Text, &((EFI_IFR_FORM *) FormData)->FormTitle, sizeof (UINT16));
    TargetTag->VariableNumber = CurrentVariable;
    if (VariableDefinitionsHead != NULL) {
      VariableName = EfiLibAllocateZeroPool (12);
      ASSERT (VariableName != NULL);
      EfiCopyMem (VariableName, L"Setup", 12);
      VariableDefinitionsHead->VariableName = VariableName;
      VariableDefinitionsHead->VariableSize = VariableSize;
      EfiCopyMem (&VariableDefinitionsHead->Guid, &Guid, sizeof (EFI_GUID));
    }
    break;

  case EFI_IFR_SUBTITLE_OP:
    TargetTag->NumberOfLines = 1;
    EfiCopyMem (&TargetTag->Text, &((EFI_IFR_SUBTITLE *) FormData)->SubTitle, sizeof (UINT16));
    TargetTag->VariableNumber = CurrentVariable;
    break;

  case EFI_IFR_TEXT_OP:
    TargetTag->NumberOfLines = 1;
    EfiCopyMem (&TargetTag->Text, &((EFI_IFR_TEXT *) FormData)->Text, sizeof (UINT16));
    EfiCopyMem (&TargetTag->Help, &((EFI_IFR_TEXT *) FormData)->Help, sizeof (UINT16));
    TargetTag->VariableNumber = CurrentVariable;

    //
    // To optimize the encoding size, certain opcodes have optional fields such as those
    // inside the if() statement.  If the encoded length is the complete size, then we
    // know we have valid data encoded that we want to integrate
    //
    if (((EFI_IFR_TEXT *) FormData)->Header.Length == sizeof (EFI_IFR_TEXT)) {
      //
      // Text has no help associated with it, but in case there is a second entry due to
      // dynamic/interactive flags being active, bring this data over.
      //
      EfiCopyMem (&TargetTag->TextTwo, &((EFI_IFR_TEXT *) FormData)->TextTwo, sizeof (UINT16));
      TargetTag->Flags = ((EFI_IFR_TEXT *) FormData)->Flags;
      EfiCopyMem (&TargetTag->Key, &((EFI_IFR_TEXT *) FormData)->Key, sizeof (UINT16));
    }
    break;

  case EFI_IFR_ONE_OF_OPTION_OP:
    EfiCopyMem (&TargetTag->Text, &((EFI_IFR_ONE_OF_OPTION *) FormData)->Option, sizeof (UINT16));
    EfiCopyMem (&TargetTag->Value, &((EFI_IFR_ONE_OF_OPTION *) FormData)->Value, sizeof (UINT16));
    TargetTag->Flags = ((EFI_IFR_ONE_OF_OPTION *) FormData)->Flags;
    EfiCopyMem (&TargetTag->Key, &((EFI_IFR_ONE_OF_OPTION *) FormData)->Key, sizeof (UINT16));
    TargetTag->VariableNumber = CurrentVariable;
    break;

  case EFI_IFR_CHECKBOX_OP:
    TargetTag->Flags          = ((EFI_IFR_CHECK_BOX *) FormData)->Flags;
    TargetTag->ResetRequired  = (BOOLEAN) (TargetTag->Flags & EFI_IFR_FLAG_RESET_REQUIRED);
    EfiCopyMem (&TargetTag->Key, &((EFI_IFR_CHECK_BOX *) FormData)->Key, sizeof (UINT16));
    TargetTag->VariableNumber = CurrentVariable;
    break;

  case EFI_IFR_NUMERIC_OP:
    TargetTag->Flags = ((EFI_IFR_NUMERIC *) FormData)->Flags;
    EfiCopyMem (&TargetTag->Key, &((EFI_IFR_NUMERIC *) FormData)->Key, sizeof (UINT16));
    TargetTag->VariableNumber = CurrentVariable;
    break;

  case EFI_IFR_STRING_OP:
    TempValue = 0;
    EfiCopyMem (&TempValue, &((EFI_IFR_STRING *) FormData)->MinSize, sizeof (UINT8));
    TempValue = (UINT16) (TempValue * 2);
    EfiCopyMem (&TargetTag->Minimum, &TempValue, sizeof (UINT16));

    EfiCopyMem (&TempValue, &((EFI_IFR_STRING *) FormData)->MaxSize, sizeof (UINT8));
    TempValue = (UINT16) (TempValue * 2);
    EfiCopyMem (&TargetTag->Maximum, &TempValue, sizeof (UINT16));
    EfiCopyMem (&TargetTag->StorageWidth, &TempValue, sizeof (UINT16));
    TargetTag->Flags          = (UINT8) (((EFI_IFR_STRING *) FormData)->Flags);
    TargetTag->ResetRequired  = (BOOLEAN) (TargetTag->Flags & EFI_IFR_FLAG_RESET_REQUIRED);
    EfiCopyMem (&TargetTag->Key, &((EFI_IFR_STRING *) FormData)->Key, sizeof (UINT16));
    TargetTag->VariableNumber = CurrentVariable;
    break;

  case EFI_IFR_PASSWORD_OP:
    TempValue = 0;
    EfiCopyMem (&TempValue, &((EFI_IFR_PASSWORD *) FormData)->MinSize, sizeof (UINT8));
    TempValue = (UINT16) (TempValue * 2);
    EfiCopyMem (&TargetTag->Minimum, &TempValue, sizeof (UINT16));

    EfiCopyMem (&TempValue, &((EFI_IFR_PASSWORD *) FormData)->MaxSize, sizeof (UINT8));
    TempValue = (UINT16) (TempValue * 2);
    EfiCopyMem (&TargetTag->Maximum, &TempValue, sizeof (UINT16));
    EfiCopyMem (&TargetTag->StorageWidth, &TempValue, sizeof (UINT16));
    TargetTag->Flags          = ((EFI_IFR_PASSWORD *) FormData)->Flags;
    TargetTag->ResetRequired  = (BOOLEAN) (TargetTag->Flags & EFI_IFR_FLAG_RESET_REQUIRED);
    EfiCopyMem (&TargetTag->Key, &((EFI_IFR_PASSWORD *) FormData)->Key, sizeof (UINT16));
    EfiCopyMem (&TargetTag->Encoding, &((EFI_IFR_PASSWORD *) FormData)->Encoding, sizeof (UINT16));
    TargetTag->VariableNumber = CurrentVariable;
    break;

  case EFI_IFR_VARSTORE_OP:
    //
    // It should NEVER be NULL
    //
    if (VariableDefinitionsHead == NULL) {
      break;
    }

    VariableDefinitions = VariableDefinitionsHead;

    //
    // Advance VariableDefinitions to the last entry
    //
    for (; VariableDefinitions != NULL; VariableDefinitions = VariableDefinitions->Next) {
      PreviousVariableDefinitions = VariableDefinitions;
      //
      // If there is a variable with this GUID and ID already, we need to bail out
      //
      if (!EfiCompareMem (&VariableDefinitions->Guid, &((EFI_IFR_VARSTORE *) FormData)->Guid, sizeof (EFI_GUID)) &&
          !EfiCompareMem (&VariableDefinitions->VariableId, &((EFI_IFR_VARSTORE *) FormData)->VarId, sizeof (UINT16))
            ) {
        return ;
      }

      if (VariableDefinitions->Next == NULL) {
        break;
      }
    }
    //
    // If the last entry has a variable in it already, allocate a new entry and use it
    //
    if (VariableDefinitions->VariableName != NULL) {
      VariableDefinitions->Next = EfiLibAllocateZeroPool (sizeof (EFI_VARIABLE_DEFINITION));
      ASSERT (VariableDefinitions->Next != NULL);
      PreviousVariableDefinitions   = VariableDefinitions;
      VariableDefinitions           = VariableDefinitions->Next;
      VariableDefinitions->Previous = PreviousVariableDefinitions;
    }
    //
    // Copy the Variable data to our linked list
    //
    EfiCopyMem (&VariableDefinitions->VariableId, &((EFI_IFR_VARSTORE *) FormData)->VarId, sizeof (UINT16));
    EfiCopyMem (&VariableDefinitions->VariableSize, &((EFI_IFR_VARSTORE *) FormData)->Size, sizeof (UINT16));
    EfiCopyMem (&VariableDefinitions->Guid, &((EFI_IFR_VARSTORE *) FormData)->Guid, sizeof (EFI_GUID));

    //
    // The ASCII String which is immediately past the EFI_IFR_VARSTORE is inferred by the structure definition
    // due to it being variable sized.  There are rules preventing it from being > 40 characters long and should
    // be enforced by the compiler.
    //
    AsciiString                       = (CHAR8 *) (&((EFI_IFR_VARSTORE *) FormData)->Size);
    AsciiString                       = AsciiString + 2;
    VariableDefinitions->VariableName = EfiLibAllocateZeroPool ((EfiAsciiStrLen (AsciiString) + 1) * 2);
    ASSERT (VariableDefinitions->VariableName != NULL);
    for (Index = 0; AsciiString[Index] != 0; Index++) {
      VariableDefinitions->VariableName[Index] = (CHAR16) AsciiString[Index];
    }

    VariableDefinitions->VariableName[Index] = 0;

    //
    // Propogate the tag information for this op-code
    //
    EfiCopyMem (&TargetTag->VariableNumber, &((EFI_IFR_VARSTORE *) FormData)->VarId, sizeof (UINT16));
    EfiCopyMem (&TargetTag->GuidValue, &((EFI_IFR_VARSTORE *) FormData)->Guid, sizeof (EFI_GUID));
    EfiCopyMem (&TargetTag->StorageWidth, &((EFI_IFR_VARSTORE *) FormData)->Size, sizeof (UINT16));
    EfiCopyMem (&TargetTag->Maximum, &((EFI_IFR_VARSTORE *) FormData)->Size, sizeof (UINT16));
    break;

  case EFI_IFR_VARSTORE_SELECT_OP:
    EfiCopyMem (&TargetTag->VariableNumber, &((EFI_IFR_VARSTORE_SELECT *) FormData)->VarId, sizeof (UINT16));
    EfiCopyMem (&CurrentVariable, &((EFI_IFR_VARSTORE_SELECT *) FormData)->VarId, sizeof (UINT16));
    CurrentVariable2 = CurrentVariable;
    break;

  case EFI_IFR_VARSTORE_SELECT_PAIR_OP:
    EfiCopyMem (&TargetTag->VariableNumber, &((EFI_IFR_VARSTORE_SELECT_PAIR *) FormData)->VarId, sizeof (UINT16));
    EfiCopyMem (
      &TargetTag->VariableNumber2,
      &((EFI_IFR_VARSTORE_SELECT_PAIR *) FormData)->SecondaryVarId,
      sizeof (UINT16)
      );
    EfiCopyMem (&CurrentVariable, &((EFI_IFR_VARSTORE_SELECT_PAIR *) FormData)->VarId, sizeof (UINT16));
    EfiCopyMem (&CurrentVariable2, &((EFI_IFR_VARSTORE_SELECT_PAIR *) FormData)->SecondaryVarId, sizeof (UINT16));
    break;

  case EFI_IFR_REF_OP:
    TargetTag->NumberOfLines = 1;
    EfiCopyMem (&TargetTag->Id, &((EFI_IFR_REF *) FormData)->FormId, sizeof (UINT16));
    EfiCopyMem (&TargetTag->Key, &((EFI_IFR_REF *) FormData)->Key, sizeof (UINT16));
    EfiCopyMem (&TargetTag->Text, &((EFI_IFR_REF *) FormData)->Prompt, sizeof (UINT16));
    EfiCopyMem (&TargetTag->Help, &((EFI_IFR_REF *) FormData)->Help, sizeof (UINT16));
    TargetTag->Flags          = ((EFI_IFR_REF *) FormData)->Flags;
    TargetTag->VariableNumber = CurrentVariable;
    break;

  case EFI_IFR_EQ_ID_VAL_OP:
    EfiCopyMem (&TargetTag->Value, &((EFI_IFR_EQ_ID_VAL *) FormData)->Value, sizeof (UINT16));
    EfiCopyMem (&TargetTag->Id, &((EFI_IFR_EQ_ID_VAL *) FormData)->QuestionId, sizeof (UINT16));
    TargetTag->StorageWidth   = ((EFI_IFR_EQ_ID_VAL *) FormData)->Width;
    TargetTag->VariableNumber = CurrentVariable;
    break;

  case EFI_IFR_EQ_VAR_VAL_OP:
    EfiCopyMem (&TargetTag->Value, &((EFI_IFR_EQ_VAR_VAL *) FormData)->Value, sizeof (UINT16));
    EfiCopyMem (&TargetTag->Id, &((EFI_IFR_EQ_VAR_VAL *) FormData)->VariableId, sizeof (UINT16));
    TargetTag->VariableNumber = CurrentVariable;
    break;

  case EFI_IFR_EQ_ID_ID_OP:
    EfiCopyMem (&TargetTag->Id, &((EFI_IFR_EQ_ID_ID *) FormData)->QuestionId1, sizeof (UINT16));
    EfiCopyMem (&TargetTag->Id2, &((EFI_IFR_EQ_ID_ID *) FormData)->QuestionId2, sizeof (UINT16));
    TargetTag->StorageWidth   = ((EFI_IFR_EQ_ID_ID *) FormData)->Width;
    TargetTag->VariableNumber = CurrentVariable;
    TargetTag->VariableNumber = CurrentVariable2;
    break;

  case EFI_IFR_EQ_ID_LIST_OP:
    EfiCopyMem (&TargetTag->Id, &((EFI_IFR_EQ_ID_LIST *) FormData)->QuestionId, sizeof (UINT16));
    EfiCopyMem (&TargetTag->Id2, &((EFI_IFR_EQ_ID_LIST *) FormData)->ListLength, sizeof (UINT16));
    TargetTag->StorageWidth = ((EFI_IFR_EQ_ID_LIST *) FormData)->Width;

    TargetTag->IntList      = EfiLibAllocateZeroPool (TargetTag->Id2 * sizeof (UINT16));
    ASSERT (TargetTag->IntList);

    for (TempValue = 0; TempValue < TargetTag->Id2; TempValue++) {
      EfiCopyMem (
        &TargetTag->IntList[TempValue],
        &((EFI_IFR_EQ_ID_LIST *) FormData)->ValueList[TempValue],
        sizeof (UINT16)
        );
    }

    TargetTag->VariableNumber = CurrentVariable;
    break;

  case EFI_IFR_FORM_SET_OP:
    EfiCopyMem (&VariableSize, &((EFI_IFR_FORM_SET *) FormData)->NvDataSize, sizeof (UINT16));
    EfiCopyMem (&Guid, &((EFI_IFR_FORM_SET *) FormData)->Guid, sizeof (EFI_GUID));
    //
    // If there is a size specified in the formste, we will establish a "default" variable
    //
    if (VariableDefinitionsHead != NULL) {
      VariableName = EfiLibAllocateZeroPool (12);
      ASSERT (VariableName != NULL);
      EfiCopyMem (VariableName, L"Setup", 12);
      VariableDefinitionsHead->VariableName = VariableName;
      VariableDefinitionsHead->VariableSize = VariableSize;
      EfiCopyMem (&VariableDefinitionsHead->Guid, &Guid, sizeof (EFI_GUID));
    }
    break;

  case EFI_IFR_END_FORM_SET_OP:
    CurrentVariable   = 0;
    CurrentVariable2  = 0;
    break;
  }

  return ;
}