Enhance VfrCompiler to parse following case: 1. EFI VarStore can contain bit fields in their structure. 2. For question Oneof/Checkbox/numeric, their storage can be bit fields of an EFI VarStore.
Cc: Eric Dong <eric.d...@intel.com> Cc: Liming Gao <liming....@intel.com> Cc: Dandan Bi <dandan...@intel.com> Contributed-under: TianoCore Contribution Agreement 1.0 Signed-off-by: Dandan Bi <dandan...@intel.com> --- BaseTools/Source/C/VfrCompile/VfrFormPkg.h | 14 +- BaseTools/Source/C/VfrCompile/VfrSyntax.g | 505 +++++++++++++++++++----- BaseTools/Source/C/VfrCompile/VfrUtilityLib.cpp | 406 ++++++++++++++++++- BaseTools/Source/C/VfrCompile/VfrUtilityLib.h | 25 +- 4 files changed, 825 insertions(+), 125 deletions(-) diff --git a/BaseTools/Source/C/VfrCompile/VfrFormPkg.h b/BaseTools/Source/C/VfrCompile/VfrFormPkg.h index 17ab14c..18c2afb 100644 --- a/BaseTools/Source/C/VfrCompile/VfrFormPkg.h +++ b/BaseTools/Source/C/VfrCompile/VfrFormPkg.h @@ -1,10 +1,10 @@ /** @file The definition of CFormPkg's member function -Copyright (c) 2004 - 2016, Intel Corporation. All rights reserved.<BR> +Copyright (c) 2004 - 2017, Intel Corporation. All rights reserved.<BR> 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 @@ -565,12 +565,16 @@ public: } } mMinMaxStepData->u8.Step = Step; } - UINT64 GetMinData (UINT8 VarType) { + UINT64 GetMinData (UINT8 VarType, BOOLEAN IsBitVar) { UINT64 MinValue = 0; + if (IsBitVar) { + MinValue = mMinMaxStepData->u32.MinValue; + return MinValue; + } switch (VarType) { case EFI_IFR_TYPE_NUM_SIZE_64: MinValue = mMinMaxStepData->u64.MinValue; break; case EFI_IFR_TYPE_NUM_SIZE_32: @@ -586,12 +590,16 @@ public: break; } return MinValue; } - UINT64 GetMaxData (UINT8 VarType) { + UINT64 GetMaxData (UINT8 VarType, BOOLEAN IsBitVar) { UINT64 MaxValue = 0; + if (IsBitVar) { + MaxValue = mMinMaxStepData->u32.MaxValue; + return MaxValue; + } switch (VarType) { case EFI_IFR_TYPE_NUM_SIZE_64: MaxValue = mMinMaxStepData->u64.MaxValue; break; case EFI_IFR_TYPE_NUM_SIZE_32: diff --git a/BaseTools/Source/C/VfrCompile/VfrSyntax.g b/BaseTools/Source/C/VfrCompile/VfrSyntax.g index 406dbc5..b13b6d0 100644 --- a/BaseTools/Source/C/VfrCompile/VfrSyntax.g +++ b/BaseTools/Source/C/VfrCompile/VfrSyntax.g @@ -344,11 +344,15 @@ vfrDataStructFields : dataStructFieldBool | dataStructFieldString | dataStructFieldDate | dataStructFieldTime | dataStructFieldRef | - dataStructFieldUser + dataStructFieldUser | + vfr64BitsStructField | + vfr32BitsStructField | + vfr16BitsStructField | + vfr8BitsStructField )* ; dataStructField64 : << UINT32 ArrayNum = 0; >> @@ -450,10 +454,50 @@ dataStructFieldUser : OpenBracket I:Number CloseBracket << ArrayNum = _STOU32(I->getText(), I->getLine()); >> } ";" << _PCATCH(gCVfrVarDataTypeDB.DataTypeAddField (N->getText(), T->getText(), ArrayNum), T); >> ; +vfr64BitsStructField: + << UINT32 Width = 0;>> + D:"UINT64" + N:StringIdentifier + { + ":" I:Number << Width = _STOU32(I->getText(), I->getLine());>> + } + ";" << _PCATCH(gCVfrVarDataTypeDB.DataTypeAddBitField (N->getText(), D->getText(), Width), N); >> + ; + +vfr32BitsStructField: + << UINT32 Width = 0;>> + D:"UINT32" + N:StringIdentifier + { + ":" I:Number << Width = _STOU32(I->getText(), I->getLine());>> + } + ";" << _PCATCH(gCVfrVarDataTypeDB.DataTypeAddBitField (N->getText(), D->getText(), Width), N); >> + ; + +vfr16BitsStructField: + << UINT32 Width = 0;>> + D:"UINT16" + N:StringIdentifier + { + ":" I:Number << Width = _STOU32(I->getText(), I->getLine());>> + } + ";" << _PCATCH(gCVfrVarDataTypeDB.DataTypeAddBitField (N->getText(), D->getText(), Width), N); >> + ; + +vfr8BitsStructField: + << UINT32 Width = 0;>> + D:"UINT8" + N:StringIdentifier + { + ":" I:Number << Width = _STOU32(I->getText(), I->getLine());>> + } + ";" << _PCATCH(gCVfrVarDataTypeDB.DataTypeAddBitField (N->getText(), D->getText(), Width), N); >> + ; + //***************************************************************************** // // the syntax of GUID definition // guidSubDefinition [EFI_GUID &Guid] : @@ -921,10 +965,11 @@ vfrStatementVarStoreEfi : UINT32 Size; CHAR8 *TypeName; UINT32 LineNum; CHAR8 *StoreName = NULL; BOOLEAN CustomizedName = FALSE; + BOOLEAN IsBitVarStore = FALSE; >> E:Efivarstore << VSEObj.SetLineNo(E->getLine()); >> ( TN:StringIdentifier "," << TypeName = TN->getText(); LineNum = TN->getLine(); CustomizedName = TRUE; >> | U8:"UINT8" "," << TypeName = U8->getText(); LineNum = U8->getLine(); >> @@ -934,10 +979,11 @@ vfrStatementVarStoreEfi : | U64:"UINT64" "," << TypeName = U64->getText(); LineNum = U64->getLine(); >> | D:"EFI_HII_DATE" "," << TypeName = D->getText(); LineNum = D->getLine(); >> | T:"EFI_HII_TIME" "," << TypeName = T->getText(); LineNum = T->getLine(); >> | R:"EFI_HII_REF" "," << TypeName = R->getText(); LineNum = R->getLine(); >> ) + << IsBitVarStore = gCVfrVarDataTypeDB.DataTypeHasBitField (TN->getText());>> { VarId "=" ID:Number "," << _PCATCH( (INTN)(VarStoreId = _STOU16(ID->getText(), ID->getLine())) != 0, (INTN)TRUE, @@ -984,17 +1030,27 @@ vfrStatementVarStoreEfi : >> ) Uuid "=" guidDefinition[Guid] << if (IsUEFI23EfiVarstore) { - _PCATCH(gCVfrDataStorage.DeclareBufferVarStore ( - StoreName, - &Guid, - &gCVfrVarDataTypeDB, - TypeName, - VarStoreId - ), LineNum); + if (IsBitVarStore) { + _PCATCH(gCVfrDataStorage.DeclareBitsBufferVarStore ( + StoreName, + &Guid, + &gCVfrVarDataTypeDB, + TypeName, + VarStoreId + ), LineNum); + } else { + _PCATCH(gCVfrDataStorage.DeclareBufferVarStore ( + StoreName, + &Guid, + &gCVfrVarDataTypeDB, + TypeName, + VarStoreId + ), LineNum); + } _PCATCH(gCVfrDataStorage.GetVarStoreId(StoreName, &VarStoreId, &Guid), SN); _PCATCH(gCVfrVarDataTypeDB.GetDataTypeSize(TypeName, &Size), LineNum); } else { _PCATCH(gCVfrDataStorage.DeclareBufferVarStore ( TN->getText(), @@ -1129,10 +1185,11 @@ vfrQuestionHeader[CIfrQuestionHeader & QHObj, EFI_QUESION_TYPE QType = QUESTION_ EFI_VARSTORE_INFO Info; Info.mVarType = EFI_IFR_TYPE_OTHER; Info.mVarTotalSize = 0; Info.mInfo.mVarOffset = EFI_VAROFFSET_INVALID; Info.mVarStoreId = EFI_VARSTORE_ID_INVALID; + Info.mIsBitVar = FALSE; EFI_QUESTION_ID QId = EFI_QUESTION_ID_INVALID; CHAR8 *QName = NULL; CHAR8 *VarIdStr = NULL; mUsedDefaultCount = 0; >> @@ -1185,10 +1242,62 @@ vfrQuestionHeader[CIfrQuestionHeader & QHObj, EFI_QUESION_TYPE QType = QUESTION_ } _SAVE_CURRQEST_VARINFO (Info); >> ; + vfrQuestionBaseInfo[EFI_VARSTORE_INFO & Info, EFI_QUESTION_ID & QId,EFI_QUESION_TYPE QType = QUESTION_NORMAL]: + << + CHAR8 *QName = NULL; + CHAR8 *VarIdStr = NULL; + mUsedDefaultCount = 0; + >> + { + Name "=" QN:StringIdentifier "," << + QName = QN->getText(); + _PCATCH(mCVfrQuestionDB.FindQuestion (QName), VFR_RETURN_UNDEFINED, QN, "has already been used please used anther name"); + >> + } + { V:VarId "=" vfrStorageVarId[Info, VarIdStr] "," } + { + QuestionId "=" ID:Number "," << + QId = _STOQID(ID->getText(), ID->getLine()); + _PCATCH(mCVfrQuestionDB.FindQuestion (QId), VFR_RETURN_UNDEFINED, ID, "has already been used please assign another number"); + >> + } + << + switch (QType) { + case QUESTION_NORMAL: + mCVfrQuestionDB.RegisterQuestion (QName, VarIdStr, QId); + break; + case QUESTION_DATE: + mCVfrQuestionDB.RegisterNewDateQuestion (QName, VarIdStr, QId); + break; + case QUESTION_TIME: + mCVfrQuestionDB.RegisterNewTimeQuestion (QName, VarIdStr, QId); + break; + case QUESTION_REF: + // + // VarIdStr != NULL stand for question with storagae. + // + if (VarIdStr != NULL) { + mCVfrQuestionDB.RegisterRefQuestion (QName, VarIdStr, QId); + } else { + mCVfrQuestionDB.RegisterQuestion (QName, NULL, QId); + } + break; + default: + _PCATCH(VFR_RETURN_FATAL_ERROR); + } + >> + << + if (VarIdStr != NULL) { + delete VarIdStr; + } + _SAVE_CURRQEST_VARINFO (Info); + >> + ; + questionheaderFlagsField[UINT8 & Flags] : ReadOnlyFlag << $Flags |= 0x01; >> | InteractiveFlag << $Flags |= 0x04; >> | ResetRequiredFlag << $Flags |= 0x10; >> | ReconnectRequiredFlag << $Flags |= 0x40; >> @@ -1233,10 +1342,11 @@ vfrStorageVarId[EFI_VARSTORE_INFO & Info, CHAR8 *&QuestVarIdStr, BOOLEAN CheckFl CHAR8 *SName = NULL; CHAR8 *TName = NULL; EFI_VFR_RETURN_CODE VfrReturnCode = VFR_RETURN_SUCCESS; EFI_IFR_TYPE_VALUE Dummy = gZeroEfiIfrTypeValue; EFI_GUID *VarGuid = NULL; + gNestStructureIsBitVar = FALSE; >> ( SN1:StringIdentifier << SName = SN1->getText(); _STRCAT(&VarIdStr, SN1->getText()); >> OpenBracket I1:Number CloseBracket << Idx = _STOU32(I1->getText(), I1->getLine()); @@ -1282,21 +1392,21 @@ vfrStorageVarId[EFI_VARSTORE_INFO & Info, CHAR8 *&QuestVarIdStr, BOOLEAN CheckFl VfrReturnCode = gCVfrDataStorage.GetVarStoreId(SName, &$Info.mVarStoreId, &mFormsetGuid); } if (CheckFlag || VfrReturnCode == VFR_RETURN_SUCCESS) { _PCATCH(VfrReturnCode, SN2); VarStoreType = gCVfrDataStorage.GetVarStoreType ($Info.mVarStoreId); - if (VarStoreType == EFI_VFR_VARSTORE_BUFFER) { + if (VarStoreType == EFI_VFR_VARSTORE_BUFFER || VarStoreType == EFI_VFR_VARSTORE_BUFFER_BITS) { _PCATCH(gCVfrDataStorage.GetBufferVarStoreDataTypeName(Info.mVarStoreId, &TName), SN2); _STRCAT(&VarStr, TName); } } >> ( "." << if (CheckFlag || VfrReturnCode == VFR_RETURN_SUCCESS) { - _PCATCH(((VarStoreType != EFI_VFR_VARSTORE_BUFFER) ? VFR_RETURN_EFIVARSTORE_USE_ERROR : VFR_RETURN_SUCCESS), SN2); + _PCATCH((((VarStoreType != EFI_VFR_VARSTORE_BUFFER)&& (VarStoreType != EFI_VFR_VARSTORE_BUFFER_BITS))? VFR_RETURN_EFIVARSTORE_USE_ERROR : VFR_RETURN_SUCCESS), SN2); } _STRCAT(&VarIdStr, "."); _STRCAT(&VarStr, "."); >> SF:StringIdentifier << _STRCAT(&VarIdStr, SF->getText()); _STRCAT(&VarStr, SF->getText()); >> { @@ -1321,11 +1431,31 @@ vfrStorageVarId[EFI_VARSTORE_INFO & Info, CHAR8 *&QuestVarIdStr, BOOLEAN CheckFl switch (VarStoreType) { case EFI_VFR_VARSTORE_EFI: _PCATCH(gCVfrDataStorage.GetEfiVarStoreInfo (&$Info), SN2); break; case EFI_VFR_VARSTORE_BUFFER: - _PCATCH(gCVfrVarDataTypeDB.GetDataFieldInfo (VarStr, $Info.mInfo.mVarOffset, $Info.mVarType, $Info.mVarTotalSize), SN2->getLine(), VarStr); + _PCATCH(gCVfrVarDataTypeDB.GetDataFieldInfo (VarStr, $Info.mInfo.mVarOffset, $Info.mVarType, $Info.mVarTotalSize, FALSE), SN2->getLine(), VarStr); + VarGuid = gCVfrDataStorage.GetVarStoreGuid($Info.mVarStoreId); + _PCATCH((EFI_VFR_RETURN_CODE)gCVfrBufferConfig.Register ( + SName, + VarGuid, + NULL), + SN2->getLine()); + _PCATCH((EFI_VFR_RETURN_CODE)gCVfrBufferConfig.Write ( + 'a', + SName, + VarGuid, + NULL, + $Info.mVarType, + $Info.mInfo.mVarOffset, + $Info.mVarTotalSize, + Dummy), + SN2->getLine()); + _PCATCH(gCVfrDataStorage.AddBufferVarStoreFieldInfo(&$Info),SN2->getLine()); + break; + case EFI_VFR_VARSTORE_BUFFER_BITS: + _PCATCH(gCVfrVarDataTypeDB.GetDataFieldInfo (VarStr, $Info.mInfo.mVarOffset, $Info.mVarType, $Info.mVarTotalSize, TRUE), SN2->getLine(), VarStr); VarGuid = gCVfrDataStorage.GetVarStoreGuid($Info.mVarStoreId); _PCATCH((EFI_VFR_RETURN_CODE)gCVfrBufferConfig.Register ( SName, VarGuid, NULL), @@ -1338,11 +1468,12 @@ vfrStorageVarId[EFI_VARSTORE_INFO & Info, CHAR8 *&QuestVarIdStr, BOOLEAN CheckFl $Info.mVarType, $Info.mInfo.mVarOffset, $Info.mVarTotalSize, Dummy), SN2->getLine()); - _PCATCH(gCVfrDataStorage.AddBufferVarStoreFieldInfo(&$Info ),SN2->getLine()); + _PCATCH(gCVfrDataStorage.AddBufferVarStoreFieldInfo(&$Info),SN2->getLine()); + Info.mIsBitVar = TRUE; break; case EFI_VFR_VARSTORE_NAME: default: break; } @@ -1419,10 +1550,13 @@ vfrConstantValueField[UINT8 Type, EFI_IFR_TYPE_VALUE &Value, BOOLEAN &ListType] >> { "\-" << Negative = TRUE; >> } N1:Number << + if (_GET_CURRQEST_VARTINFO().mIsBitVar) { + $Value.u32 = _STOU32(N1->getText(), N1->getLine()); + } else { switch ($Type) { case EFI_IFR_TYPE_NUM_SIZE_8 : $Value.u8 = _STOU8(N1->getText(), N1->getLine()); if (IntDecStyle) { if (Negative) { @@ -1500,10 +1634,11 @@ vfrConstantValueField[UINT8 Type, EFI_IFR_TYPE_VALUE &Value, BOOLEAN &ListType] case EFI_IFR_TYPE_DATE : case EFI_IFR_TYPE_REF : default : break; } + } >> | B1:True << $Value.b = TRUE; >> | B2:False << $Value.b = FALSE; >> | O1:One << $Value.u8 = _STOU8(O1->getText(), O1->getLine()); >> | O2:Ones << $Value.u64 = _STOU64(O2->getText(), O2->getLine()); >> @@ -1672,42 +1807,48 @@ vfrStatementDefault : "=" vfrConstantValueField[_GET_CURRQEST_DATATYPE(), *Val, ArrayType] "," << if (gCurrentMinMaxData != NULL && gCurrentMinMaxData->IsNumericOpcode()) { //check default value is valid for Numeric Opcode NumericQst = (CIfrNumeric *) gCurrentQuestion; - if ((NumericQst->GetNumericFlags() & EFI_IFR_DISPLAY) == 0) { + if ((NumericQst->GetNumericFlags() & EFI_IFR_DISPLAY) == 0 && !(_GET_CURRQEST_VARTINFO().mIsBitVar)) { switch (_GET_CURRQEST_DATATYPE()) { case EFI_IFR_TYPE_NUM_SIZE_8: - if (((INT8) Val->u8 < (INT8) gCurrentMinMaxData->GetMinData(_GET_CURRQEST_DATATYPE())) || - ((INT8) Val->u8 > (INT8) gCurrentMinMaxData->GetMaxData(_GET_CURRQEST_DATATYPE()))) { + if (((INT8) Val->u8 < (INT8) gCurrentMinMaxData->GetMinData(_GET_CURRQEST_DATATYPE(), FALSE)) || + ((INT8) Val->u8 > (INT8) gCurrentMinMaxData->GetMaxData(_GET_CURRQEST_DATATYPE(), FALSE))) { _PCATCH (VFR_RETURN_INVALID_PARAMETER, D->getLine(), "Numeric default value must be between MinValue and MaxValue."); } break; case EFI_IFR_TYPE_NUM_SIZE_16: - if (((INT16) Val->u16 < (INT16) gCurrentMinMaxData->GetMinData(_GET_CURRQEST_DATATYPE())) || - ((INT16) Val->u16 > (INT16) gCurrentMinMaxData->GetMaxData(_GET_CURRQEST_DATATYPE()))) { + if (((INT16) Val->u16 < (INT16) gCurrentMinMaxData->GetMinData(_GET_CURRQEST_DATATYPE(), FALSE)) || + ((INT16) Val->u16 > (INT16) gCurrentMinMaxData->GetMaxData(_GET_CURRQEST_DATATYPE(), FALSE))) { _PCATCH (VFR_RETURN_INVALID_PARAMETER, D->getLine(), "Numeric default value must be between MinValue and MaxValue."); } break; case EFI_IFR_TYPE_NUM_SIZE_32: - if (((INT32) Val->u32 < (INT32) gCurrentMinMaxData->GetMinData(_GET_CURRQEST_DATATYPE())) || - ((INT32) Val->u32 > (INT32) gCurrentMinMaxData->GetMaxData(_GET_CURRQEST_DATATYPE()))) { + if (((INT32) Val->u32 < (INT32) gCurrentMinMaxData->GetMinData(_GET_CURRQEST_DATATYPE(), FALSE)) || + ((INT32) Val->u32 > (INT32) gCurrentMinMaxData->GetMaxData(_GET_CURRQEST_DATATYPE(), FALSE))) { _PCATCH (VFR_RETURN_INVALID_PARAMETER, D->getLine(), "Numeric default value must be between MinValue and MaxValue."); } break; case EFI_IFR_TYPE_NUM_SIZE_64: - if (((INT64) Val->u64 < (INT64) gCurrentMinMaxData->GetMinData(_GET_CURRQEST_DATATYPE())) || - ((INT64) Val->u64 > (INT64) gCurrentMinMaxData->GetMaxData(_GET_CURRQEST_DATATYPE()))) { + if (((INT64) Val->u64 < (INT64) gCurrentMinMaxData->GetMinData(_GET_CURRQEST_DATATYPE(), FALSE)) || + ((INT64) Val->u64 > (INT64) gCurrentMinMaxData->GetMaxData(_GET_CURRQEST_DATATYPE(), FALSE))) { _PCATCH (VFR_RETURN_INVALID_PARAMETER, D->getLine(), "Numeric default value must be between MinValue and MaxValue."); } break; default: break; } } else { - if (Val->u64 < gCurrentMinMaxData->GetMinData(_GET_CURRQEST_DATATYPE()) || Val->u64 > gCurrentMinMaxData->GetMaxData(_GET_CURRQEST_DATATYPE())) { + if (_GET_CURRQEST_VARTINFO().mIsBitVar) { + if (Val->u32 < gCurrentMinMaxData->GetMinData(_GET_CURRQEST_DATATYPE(), TRUE) || Val->u32 > gCurrentMinMaxData->GetMaxData(_GET_CURRQEST_DATATYPE(), TRUE)) { _PCATCH (VFR_RETURN_INVALID_PARAMETER, D->getLine(), "Numeric default value must be between MinValue and MaxValue."); + } + } else { + if (Val->u64 < gCurrentMinMaxData->GetMinData(_GET_CURRQEST_DATATYPE(), FALSE) || Val->u64 > gCurrentMinMaxData->GetMaxData(_GET_CURRQEST_DATATYPE(), FALSE)) { + _PCATCH (VFR_RETURN_INVALID_PARAMETER, D->getLine(), "Numeric default value must be between MinValue and MaxValue."); + } } } } if (_GET_CURRQEST_DATATYPE() == EFI_IFR_TYPE_OTHER) { _PCATCH (VFR_RETURN_FATAL_ERROR, D->getLine(), "Default data type error."); @@ -1742,21 +1883,29 @@ vfrStatementDefault : default: break; } } else { - _PCATCH (gCVfrVarDataTypeDB.GetDataTypeSize (_GET_CURRQEST_DATATYPE(), &Size), D->getLine()); + if (_GET_CURRQEST_VARTINFO().mIsBitVar) { + Size = sizeof (UINT32); + } else { + _PCATCH (gCVfrVarDataTypeDB.GetDataTypeSize (_GET_CURRQEST_DATATYPE(), &Size), D->getLine()); + } } Size += OFFSET_OF (EFI_IFR_DEFAULT, Value); DObj = new CIfrDefault ((UINT8)Size); DObj->SetLineNo(D->getLine()); if (ArrayType) { DObj->SetType (EFI_IFR_TYPE_BUFFER); } else if (gIsStringOp) { DObj->SetType (EFI_IFR_TYPE_STRING); } else { - DObj->SetType (_GET_CURRQEST_DATATYPE()); + if (_GET_CURRQEST_VARTINFO().mIsBitVar) { + DObj->SetType (EFI_IFR_TYPE_NUM_SIZE_32); + } else { + DObj->SetType (_GET_CURRQEST_DATATYPE()); + } } DObj->SetValue(*Val); >> | << IsExp = TRUE; DObj2 = new CIfrDefault2; DObj2->SetLineNo(D->getLine()); DObj2->SetScope (1); >> vfrStatementValue "," << CIfrEnd EndObj1; EndObj1.SetLineNo(D->getLine()); >> @@ -2159,39 +2308,70 @@ vfrStatementBooleanType : // default value = TRUE, defaultstore = MyDefaultStore, // endcheckbox; // vfrStatementCheckBox : << - CIfrCheckBox CBObj; + CIfrCheckBox *CBObj = NULL; EFI_IFR_TYPE_VALUE Val = gZeroEfiIfrTypeValue; CHAR8 *VarStoreName = NULL; UINT32 DataTypeSize; EFI_GUID *VarStoreGuid = NULL; + CIfrGuid *GuidObj = NULL; + EFI_QUESTION_ID QId = EFI_QUESTION_ID_INVALID;; + EFI_VARSTORE_INFO Info; + Info.mVarType = EFI_IFR_TYPE_OTHER; + Info.mVarTotalSize = 0; + Info.mInfo.mVarOffset = EFI_VAROFFSET_INVALID; + Info.mVarStoreId = EFI_VARSTORE_ID_INVALID; + Info.mIsBitVar = FALSE; >> - L:CheckBox << CBObj.SetLineNo(L->getLine()); >> - vfrQuestionHeader[CBObj] "," << //check data type + L:CheckBox + vfrQuestionBaseInfo[Info, QId] << + if (_GET_CURRQEST_VARTINFO().mIsBitVar || gNestStructureIsBitVar) { + GuidObj = new CIfrGuid(0); + GuidObj->SetGuid (&gBitVarstoreGuid); + GuidObj->SetLineNo(L->getLine()); + } + CBObj = new CIfrCheckBox; + CBObj->SetLineNo(L->getLine()); + CBObj->SetQuestionId (QId); + CBObj->SetVarStoreInfo (&Info); + >> + vfrStatementHeader[CBObj]"," << //check data type if (_GET_CURRQEST_DATATYPE() == EFI_IFR_TYPE_OTHER) { _GET_CURRQEST_VARTINFO().mVarType = EFI_IFR_TYPE_BOOLEAN; } if (_GET_CURRQEST_VARTINFO().mVarStoreId != EFI_VARSTORE_ID_INVALID) { - _PCATCH (gCVfrVarDataTypeDB.GetDataTypeSize (_GET_CURRQEST_DATATYPE(), &DataTypeSize), L->getLine(), "CheckBox varid is not the valid data type"); - if (DataTypeSize != 0 && DataTypeSize != _GET_CURRQEST_VARSIZE()) { - _PCATCH (VFR_RETURN_INVALID_PARAMETER, L->getLine(), "CheckBox varid doesn't support array"); - } else if ((gCVfrDataStorage.GetVarStoreType (_GET_CURRQEST_VARTINFO().mVarStoreId) == EFI_VFR_VARSTORE_BUFFER) && - (_GET_CURRQEST_VARSIZE() != sizeof (BOOLEAN))) { - _PCATCH (VFR_RETURN_INVALID_PARAMETER, L->getLine(), "CheckBox varid only support BOOLEAN data type"); + // + // Check whether the question refers to a bit field, if yes. create a Guid to + // indicate the question refers to a bit field. + // + if (_GET_CURRQEST_VARTINFO ().mIsBitVar || gNestStructureIsBitVar) { + _PCATCH (gCVfrVarDataTypeDB.GetDataTypeSize (_GET_CURRQEST_DATATYPE(), &DataTypeSize), L->getLine(), "CheckBox varid is not the valid data type"); + if ((gCVfrDataStorage.GetVarStoreType (_GET_CURRQEST_VARTINFO().mVarStoreId) == EFI_VFR_VARSTORE_BUFFER_BITS) && + (_GET_CURRQEST_VARSIZE() != 1)) { + _PCATCH (VFR_RETURN_INVALID_PARAMETER, L->getLine(), "CheckBox varid only occupy 1 bit in Bit Varstore"); + } + } else { + _PCATCH (gCVfrVarDataTypeDB.GetDataTypeSize (_GET_CURRQEST_DATATYPE(), &DataTypeSize), L->getLine(), "CheckBox varid is not the valid data type"); + if (DataTypeSize != 0 && DataTypeSize != _GET_CURRQEST_VARSIZE()) { + _PCATCH (VFR_RETURN_INVALID_PARAMETER, L->getLine(), "CheckBox varid doesn't support array"); + } else if ((gCVfrDataStorage.GetVarStoreType (_GET_CURRQEST_VARTINFO().mVarStoreId) == EFI_VFR_VARSTORE_BUFFER) && + (_GET_CURRQEST_VARSIZE() != sizeof (BOOLEAN))) { + _PCATCH (VFR_RETURN_INVALID_PARAMETER, L->getLine(), "CheckBox varid only support BOOLEAN data type"); + } } } >> { - F:FLAGS "=" vfrCheckBoxFlags[CBObj, F->getLine()] "," + F:FLAGS "=" vfrCheckBoxFlags[*CBObj, F->getLine()] "," << if (_GET_CURRQEST_VARTINFO().mVarStoreId != EFI_VARSTORE_ID_INVALID) { _PCATCH(gCVfrDataStorage.GetVarStoreName (_GET_CURRQEST_VARTINFO().mVarStoreId, &VarStoreName), VFR_RETURN_SUCCESS, L, "Failed to retrieve varstore name"); VarStoreGuid = gCVfrDataStorage.GetVarStoreGuid(_GET_CURRQEST_VARTINFO().mVarStoreId); Val.b = TRUE; - if (CBObj.GetFlags () & 0x01) { + if (CBObj->GetFlags () & 0x01) { CheckDuplicateDefaultValue (EFI_HII_DEFAULT_CLASS_STANDARD, F); _PCATCH( gCVfrDefaultStore.BufferVarStoreAltConfigAdd ( EFI_HII_DEFAULT_CLASS_STANDARD, _GET_CURRQEST_VARTINFO(), @@ -2203,11 +2383,11 @@ vfrStatementCheckBox : VFR_RETURN_SUCCESS, L, "No standard default storage found" ); } - if (CBObj.GetFlags () & 0x02) { + if (CBObj->GetFlags () & 0x02) { CheckDuplicateDefaultValue (EFI_HII_DEFAULT_CLASS_MANUFACTURING, F); _PCATCH( gCVfrDefaultStore.BufferVarStoreAltConfigAdd ( EFI_HII_DEFAULT_CLASS_MANUFACTURING, _GET_CURRQEST_VARTINFO(), @@ -2223,14 +2403,21 @@ vfrStatementCheckBox : } } >> } { - Key "=" KN:Number "," << AssignQuestionKey (CBObj, KN); >> + Key "=" KN:Number "," << AssignQuestionKey (*CBObj, KN); >> } vfrStatementQuestionOptionList - E:EndCheckBox << CRT_END_OP (E); >> + E:EndCheckBox << CRT_END_OP (E); + if (GuidObj != NULL) { + GuidObj->SetScope(1); + CRT_END_OP (E); + delete GuidObj; + } + if (CBObj != NULL) delete CBObj; + >> ";" ; vfrCheckBoxFlags [CIfrCheckBox & CBObj, UINT32 LineNum] : << @@ -2436,10 +2623,13 @@ vfrSetMinMaxStep[CIfrMinMaxStepData & MMSDObj] : } I:Number "," << if (!IntDecStyle && MinNegative) { _PCATCH (VFR_RETURN_INVALID_PARAMETER, I->getLine(), "\"-\" can't be used when not in int decimal type. "); } + if (_GET_CURRQEST_VARTINFO().mIsBitVar) { + MinU4 = _STOU32(I->getText(), I->getLine()); + } else { switch (_GET_CURRQEST_DATATYPE()) { case EFI_IFR_TYPE_NUM_SIZE_64 : MinU8 = _STOU64(I->getText(), I->getLine()); if (IntDecStyle) { if (MinNegative) { @@ -2506,20 +2696,23 @@ vfrSetMinMaxStep[CIfrMinMaxStepData & MMSDObj] : if (MinNegative) { MinU1 = ~MinU1 + 1; } break; } + } >> Maximum "=" { "\-" << MaxNegative = TRUE; >> } A:Number "," << if (!IntDecStyle && MaxNegative) { _PCATCH (VFR_RETURN_INVALID_PARAMETER, A->getLine(), "\"-\" can't be used when not in int decimal type. "); } - + if (_GET_CURRQEST_VARTINFO().mIsBitVar) { + MaxU4 = _STOU32(A->getText(), A->getLine()); + } else { switch (_GET_CURRQEST_DATATYPE()) { case EFI_IFR_TYPE_NUM_SIZE_64 : MaxU8 = _STOU64(A->getText(), A->getLine()); if (IntDecStyle) { if (MaxNegative) { @@ -2622,75 +2815,122 @@ vfrSetMinMaxStep[CIfrMinMaxStepData & MMSDObj] : _PCATCH (VFR_RETURN_INVALID_PARAMETER, A->getLine(), "Maximum can't be less than Minimum"); } } break; } + } >> { STEP "=" S:Number "," << + if (_GET_CURRQEST_VARTINFO().mIsBitVar) { + StepU4 = _STOU32(S->getText(), S->getLine()); + } else { switch (_GET_CURRQEST_DATATYPE()) { case EFI_IFR_TYPE_NUM_SIZE_64 : StepU8 = _STOU64(S->getText(), S->getLine()); break; case EFI_IFR_TYPE_NUM_SIZE_32 : StepU4 = _STOU32(S->getText(), S->getLine()); break; case EFI_IFR_TYPE_NUM_SIZE_16 : StepU2 = _STOU16(S->getText(), S->getLine()); break; case EFI_IFR_TYPE_NUM_SIZE_8 : StepU1 = _STOU8(S->getText(), S->getLine()); break; } + } >> } << + if (_GET_CURRQEST_VARTINFO().mIsBitVar) { + $MMSDObj.SetMinMaxStepData (MinU4, MaxU4, StepU4); + } else { switch (_GET_CURRQEST_DATATYPE()) { case EFI_IFR_TYPE_NUM_SIZE_64 : $MMSDObj.SetMinMaxStepData (MinU8, MaxU8, StepU8); break; case EFI_IFR_TYPE_NUM_SIZE_32 : $MMSDObj.SetMinMaxStepData (MinU4, MaxU4, StepU4); break; case EFI_IFR_TYPE_NUM_SIZE_16 : $MMSDObj.SetMinMaxStepData (MinU2, MaxU2, StepU2); break; case EFI_IFR_TYPE_NUM_SIZE_8 : $MMSDObj.SetMinMaxStepData (MinU1, MaxU1, StepU1); break; } + } >> ; vfrStatementNumeric : << - CIfrNumeric NObj; + CIfrNumeric *NObj = NULL; UINT32 DataTypeSize; BOOLEAN IsSupported = TRUE; UINT8 ShrinkSize = 0; + CIfrGuid *GuidObj = NULL; + UINT8 LFlags = _GET_CURRQEST_DATATYPE() & EFI_IFR_NUMERIC_SIZE; + EFI_QUESTION_ID QId = EFI_QUESTION_ID_INVALID;; + EFI_VARSTORE_INFO Info; + Info.mVarType = EFI_IFR_TYPE_OTHER; + Info.mVarTotalSize = 0; + Info.mInfo.mVarOffset = EFI_VAROFFSET_INVALID; + Info.mVarStoreId = EFI_VARSTORE_ID_INVALID; + Info.mIsBitVar = FALSE; >> - L:Numeric << NObj.SetLineNo(L->getLine()); >> - vfrQuestionHeader[NObj] "," << // check data type + L:Numeric << >> + vfrQuestionBaseInfo[Info, QId] << + if (_GET_CURRQEST_VARTINFO().mIsBitVar || gNestStructureIsBitVar) { + GuidObj = new CIfrGuid(0); + GuidObj->SetGuid (&gBitVarstoreGuid); + GuidObj->SetLineNo(L->getLine()); + } + NObj = new CIfrNumeric; + NObj->SetLineNo(L->getLine()); + NObj->SetQuestionId (QId); + NObj->SetVarStoreInfo (&Info); + >> + vfrStatementHeader[NObj]"," + << + // check data type if (_GET_CURRQEST_VARTINFO().mVarStoreId != EFI_VARSTORE_ID_INVALID) { - _PCATCH (gCVfrVarDataTypeDB.GetDataTypeSize (_GET_CURRQEST_DATATYPE(), &DataTypeSize), L->getLine(), "Numeric varid is not the valid data type"); - if (DataTypeSize != 0 && DataTypeSize != _GET_CURRQEST_VARSIZE()) { - _PCATCH (VFR_RETURN_INVALID_PARAMETER, L->getLine(), "Numeric varid doesn't support array"); + if (_GET_CURRQEST_VARTINFO().mIsBitVar || gNestStructureIsBitVar) { + LFlags|= (0X0F & (_GET_CURRQEST_VARSIZE())); + _PCATCH(NObj->SetFlags (NObj->FLAGS(), LFlags), L->getLine()); + } else { + _PCATCH (gCVfrVarDataTypeDB.GetDataTypeSize (_GET_CURRQEST_DATATYPE(), &DataTypeSize), L->getLine(), "Numeric varid is not the valid data type"); + if (DataTypeSize != 0 && DataTypeSize != _GET_CURRQEST_VARSIZE()) { + _PCATCH (VFR_RETURN_INVALID_PARAMETER, L->getLine(), "Numeric varid doesn't support array"); + } + _PCATCH(NObj->SetFlags (NObj->FLAGS(), _GET_CURRQEST_DATATYPE()), L->getLine()); } - _PCATCH(NObj.SetFlags (NObj.FLAGS(), _GET_CURRQEST_DATATYPE()), L->getLine()); } >> - { F:FLAGS "=" vfrNumericFlags[NObj, F->getLine()] "," } + { F:FLAGS "=" vfrNumericFlags[*NObj, F->getLine()] "," } { - Key "=" KN:Number "," << AssignQuestionKey (NObj, KN); >> + Key "=" KN:Number "," << AssignQuestionKey (*NObj, KN); >> } - vfrSetMinMaxStep[NObj] << - switch (_GET_CURRQEST_DATATYPE()) { - // - // Base on the type to know the actual used size,shrink the buffer - // size allocate before. - // - case EFI_IFR_TYPE_NUM_SIZE_8: ShrinkSize = 21;break; - case EFI_IFR_TYPE_NUM_SIZE_16:ShrinkSize = 18;break; - case EFI_IFR_TYPE_NUM_SIZE_32:ShrinkSize = 12;break; - case EFI_IFR_TYPE_NUM_SIZE_64:break; - default: - IsSupported = FALSE; - break; + vfrSetMinMaxStep[*NObj] << + if (!_GET_CURRQEST_VARTINFO().mIsBitVar && !gNestStructureIsBitVar) { + switch (_GET_CURRQEST_DATATYPE()) { + // + // Base on the type to know the actual used size,shrink the buffer + // size allocate before. + // + case EFI_IFR_TYPE_NUM_SIZE_8: ShrinkSize = 21;break; + case EFI_IFR_TYPE_NUM_SIZE_16:ShrinkSize = 18;break; + case EFI_IFR_TYPE_NUM_SIZE_32:ShrinkSize = 12;break; + case EFI_IFR_TYPE_NUM_SIZE_64:break; + default: + IsSupported = FALSE; + break; + } + } else { + ShrinkSize = 0; } - NObj.ShrinkBinSize (ShrinkSize); + NObj->ShrinkBinSize (ShrinkSize); + if (!IsSupported) { _PCATCH (VFR_RETURN_INVALID_PARAMETER, L->getLine(), "Numeric question only support UINT8, UINT16, UINT32 and UINT64 data type."); } >> vfrStatementQuestionOptionList E:EndNumeric << - CRT_END_OP (E); + CRT_END_OP (E); + if (GuidObj != NULL) { + GuidObj->SetScope(1); + CRT_END_OP (E); + delete GuidObj; + } + if (NObj != NULL) delete NObj; >> ";" ; vfrNumericFlags [CIfrNumeric & NObj, UINT32 LineNum] : @@ -2702,25 +2942,34 @@ vfrNumericFlags [CIfrNumeric & NObj, UINT32 LineNum] : BOOLEAN IsDisplaySpecified = FALSE; >> numericFlagsField[HFlags, LFlags, IsSetType, IsDisplaySpecified] ( "\|" numericFlagsField[HFlags, LFlags, IsSetType, IsDisplaySpecified ] )* << //check data type flag - if (_GET_CURRQEST_VARTINFO().mVarStoreId != EFI_VARSTORE_ID_INVALID) { - VarStoreType = gCVfrDataStorage.GetVarStoreType (_GET_CURRQEST_VARTINFO().mVarStoreId); - if (VarStoreType == EFI_VFR_VARSTORE_BUFFER || VarStoreType == EFI_VFR_VARSTORE_EFI) { - if (_GET_CURRQEST_DATATYPE() != (LFlags & EFI_IFR_NUMERIC_SIZE)) { - _PCATCH(VFR_RETURN_INVALID_PARAMETER, LineNum, "Numeric Flag is not same to Numeric VarData type"); + if (!_GET_CURRQEST_VARTINFO().mIsBitVar && !gNestStructureIsBitVar) { + if (_GET_CURRQEST_VARTINFO().mVarStoreId != EFI_VARSTORE_ID_INVALID) { + VarStoreType = gCVfrDataStorage.GetVarStoreType (_GET_CURRQEST_VARTINFO().mVarStoreId); + if (VarStoreType == EFI_VFR_VARSTORE_BUFFER || VarStoreType == EFI_VFR_VARSTORE_EFI) { + if (_GET_CURRQEST_DATATYPE() != (LFlags & EFI_IFR_NUMERIC_SIZE)) { + _PCATCH(VFR_RETURN_INVALID_PARAMETER, LineNum, "Numeric Flag is not same to Numeric VarData type"); + } + } else { + // update data type for name/value store + UINT32 DataTypeSize; + _GET_CURRQEST_VARTINFO().mVarType = LFlags & EFI_IFR_NUMERIC_SIZE; + gCVfrVarDataTypeDB.GetDataTypeSize (_GET_CURRQEST_DATATYPE(), &DataTypeSize); + _GET_CURRQEST_VARTINFO().mVarTotalSize = DataTypeSize; } - } else { - // update data type for name/value store - UINT32 DataTypeSize; + } else if (IsSetType){ _GET_CURRQEST_VARTINFO().mVarType = LFlags & EFI_IFR_NUMERIC_SIZE; - gCVfrVarDataTypeDB.GetDataTypeSize (_GET_CURRQEST_DATATYPE(), &DataTypeSize); - _GET_CURRQEST_VARTINFO().mVarTotalSize = DataTypeSize; } - } else if (IsSetType){ - _GET_CURRQEST_VARTINFO().mVarType = LFlags & EFI_IFR_NUMERIC_SIZE; + } else { + if (_GET_CURRQEST_VARTINFO().mVarStoreId != EFI_VARSTORE_ID_INVALID) { + VarStoreType = gCVfrDataStorage.GetVarStoreType (_GET_CURRQEST_VARTINFO().mVarStoreId); + if (VarStoreType == EFI_VFR_VARSTORE_BUFFER_BITS) { + LFlags|= (0X0F & (_GET_CURRQEST_VARSIZE())); + } + } } _PCATCH(NObj.SetFlags (HFlags, LFlags, IsDisplaySpecified), LineNum); >> ; @@ -2736,30 +2985,57 @@ numericFlagsField [UINT8 & HFlags, UINT8 & LFlags, BOOLEAN & IsSetType, BOOLEAN | questionheaderFlagsField[HFlags] ; vfrStatementOneOf : << - CIfrOneOf OObj; + CIfrOneOf *OObj = NULL; UINT32 DataTypeSize; BOOLEAN IsSupported = TRUE; UINT8 ShrinkSize = 0; + CIfrGuid *GuidObj = NULL; + UINT8 LFlags = _GET_CURRQEST_DATATYPE() & EFI_IFR_NUMERIC_SIZE; + EFI_QUESTION_ID QId = EFI_QUESTION_ID_INVALID;; + EFI_VARSTORE_INFO Info; + Info.mVarType = EFI_IFR_TYPE_OTHER; + Info.mVarTotalSize = 0; + Info.mInfo.mVarOffset = EFI_VAROFFSET_INVALID; + Info.mVarStoreId = EFI_VARSTORE_ID_INVALID; + Info.mIsBitVar = FALSE; >> - L:OneOf << OObj.SetLineNo(L->getLine()); >> - vfrQuestionHeader[OObj] "," << //check data type + L:OneOf + vfrQuestionBaseInfo[Info, QId] << + if (_GET_CURRQEST_VARTINFO().mIsBitVar || gNestStructureIsBitVar) { + GuidObj = new CIfrGuid(0); + GuidObj->SetGuid (&gBitVarstoreGuid); + GuidObj->SetLineNo(L->getLine()); + } + OObj = new CIfrOneOf; + OObj->SetLineNo(L->getLine()); + OObj->SetQuestionId (QId); + OObj->SetVarStoreInfo (&Info); + >> + vfrStatementHeader[OObj]"," + << //check data type if (_GET_CURRQEST_VARTINFO().mVarStoreId != EFI_VARSTORE_ID_INVALID) { - _PCATCH (gCVfrVarDataTypeDB.GetDataTypeSize (_GET_CURRQEST_DATATYPE(), &DataTypeSize), L->getLine(), "OneOf varid is not the valid data type"); - if (DataTypeSize != 0 && DataTypeSize != _GET_CURRQEST_VARSIZE()) { - _PCATCH (VFR_RETURN_INVALID_PARAMETER, L->getLine(), "OneOf varid doesn't support array"); + if (_GET_CURRQEST_VARTINFO().mIsBitVar || gNestStructureIsBitVar) { + LFlags|= (0X0F & (_GET_CURRQEST_VARSIZE())); + _PCATCH(OObj->SetFlags (OObj->FLAGS(), LFlags), L->getLine()); + } else { + _PCATCH (gCVfrVarDataTypeDB.GetDataTypeSize (_GET_CURRQEST_DATATYPE(), &DataTypeSize), L->getLine(), "OneOf varid is not the valid data type"); + if (DataTypeSize != 0 && DataTypeSize != _GET_CURRQEST_VARSIZE()) { + _PCATCH (VFR_RETURN_INVALID_PARAMETER, L->getLine(), "OneOf varid doesn't support array"); + } + _PCATCH(OObj->SetFlags (OObj->FLAGS(), _GET_CURRQEST_DATATYPE()), L->getLine()); } - _PCATCH(OObj.SetFlags (OObj.FLAGS(), _GET_CURRQEST_DATATYPE()), L->getLine()); } >> - { F:FLAGS "=" vfrOneofFlagsField[OObj, F->getLine()] "," } + { F:FLAGS "=" vfrOneofFlagsField[*OObj, F->getLine()] "," } { - vfrSetMinMaxStep[OObj] + vfrSetMinMaxStep[*OObj] } << + if (!_GET_CURRQEST_VARTINFO().mIsBitVar && !gNestStructureIsBitVar) { switch (_GET_CURRQEST_DATATYPE()) { // // Base on the type to know the actual used size,shrink the buffer // size allocate before. // @@ -2769,18 +3045,28 @@ vfrStatementOneOf : case EFI_IFR_TYPE_NUM_SIZE_64:break; default: IsSupported = FALSE; break; } - OObj.ShrinkBinSize (ShrinkSize); + } else { + ShrinkSize = 0; + } + OObj->ShrinkBinSize (ShrinkSize); + if (!IsSupported) { _PCATCH (VFR_RETURN_INVALID_PARAMETER, L->getLine(), "OneOf question only support UINT8, UINT16, UINT32 and UINT64 data type."); } >> vfrStatementQuestionOptionList E:EndOneOf << - CRT_END_OP (E); + CRT_END_OP (E); + if (GuidObj != NULL) { + GuidObj->SetScope(1); + CRT_END_OP (E); + delete GuidObj; + } + if (OObj != NULL) delete OObj; >> ";" ; vfrOneofFlagsField [CIfrOneOf & OObj, UINT32 LineNum] : @@ -2792,25 +3078,34 @@ vfrOneofFlagsField [CIfrOneOf & OObj, UINT32 LineNum] : BOOLEAN IsDisplaySpecified = FALSE; >> numericFlagsField[HFlags, LFlags, IsSetType, IsDisplaySpecified] ( "\|" numericFlagsField[HFlags, LFlags, IsSetType, IsDisplaySpecified] )* << //check data type flag - if (_GET_CURRQEST_VARTINFO().mVarStoreId != EFI_VARSTORE_ID_INVALID) { - VarStoreType = gCVfrDataStorage.GetVarStoreType (_GET_CURRQEST_VARTINFO().mVarStoreId); - if (VarStoreType == EFI_VFR_VARSTORE_BUFFER || VarStoreType == EFI_VFR_VARSTORE_EFI) { - if (_GET_CURRQEST_DATATYPE() != (LFlags & EFI_IFR_NUMERIC_SIZE)) { - _PCATCH(VFR_RETURN_INVALID_PARAMETER, LineNum, "Numeric Flag is not same to Numeric VarData type"); + if (!_GET_CURRQEST_VARTINFO().mIsBitVar && !gNestStructureIsBitVar) { + if (_GET_CURRQEST_VARTINFO().mVarStoreId != EFI_VARSTORE_ID_INVALID) { + VarStoreType = gCVfrDataStorage.GetVarStoreType (_GET_CURRQEST_VARTINFO().mVarStoreId); + if (VarStoreType == EFI_VFR_VARSTORE_BUFFER || VarStoreType == EFI_VFR_VARSTORE_EFI) { + if (_GET_CURRQEST_DATATYPE() != (LFlags & EFI_IFR_NUMERIC_SIZE)) { + _PCATCH(VFR_RETURN_INVALID_PARAMETER, LineNum, "Numeric Flag is not same to Numeric VarData type"); + } + } else { + // update data type for Name/Value store + UINT32 DataTypeSize; + _GET_CURRQEST_VARTINFO().mVarType = LFlags & EFI_IFR_NUMERIC_SIZE; + gCVfrVarDataTypeDB.GetDataTypeSize (_GET_CURRQEST_DATATYPE(), &DataTypeSize); + _GET_CURRQEST_VARTINFO().mVarTotalSize = DataTypeSize; } - } else { - // update data type for Name/Value store - UINT32 DataTypeSize; + } else if (IsSetType){ _GET_CURRQEST_VARTINFO().mVarType = LFlags & EFI_IFR_NUMERIC_SIZE; - gCVfrVarDataTypeDB.GetDataTypeSize (_GET_CURRQEST_DATATYPE(), &DataTypeSize); - _GET_CURRQEST_VARTINFO().mVarTotalSize = DataTypeSize; } - } else if (IsSetType){ - _GET_CURRQEST_VARTINFO().mVarType = LFlags & EFI_IFR_NUMERIC_SIZE; + } else { + if (_GET_CURRQEST_VARTINFO().mVarStoreId != EFI_VARSTORE_ID_INVALID) { + VarStoreType = gCVfrDataStorage.GetVarStoreType (_GET_CURRQEST_VARTINFO().mVarStoreId); + if (VarStoreType == EFI_VFR_VARSTORE_BUFFER_BITS) { + LFlags|= (0X0F & (_GET_CURRQEST_VARSIZE())); + } + } } _PCATCH(OObj.SetFlags (HFlags, LFlags), LineNum); >> ; @@ -3363,10 +3658,13 @@ vfrStatementOneOfOption : Value "=" vfrConstantValueField[_GET_CURRQEST_DATATYPE(), *Val, ArrayType] "," << if (gCurrentMinMaxData != NULL) { //set min/max value for oneof opcode UINT64 Step = gCurrentMinMaxData->GetStepData(_GET_CURRQEST_DATATYPE()); + if (_GET_CURRQEST_VARTINFO().mIsBitVar) { + gCurrentMinMaxData->SetMinMaxStepData(Val->u32, Val->u32, (UINT32) Step); + } else { switch (_GET_CURRQEST_DATATYPE()) { case EFI_IFR_TYPE_NUM_SIZE_64: gCurrentMinMaxData->SetMinMaxStepData(Val->u64, Val->u64, Step); break; case EFI_IFR_TYPE_NUM_SIZE_32: @@ -3379,10 +3677,11 @@ vfrStatementOneOfOption : gCurrentMinMaxData->SetMinMaxStepData(Val->u8, Val->u8, (UINT8) Step); break; default: break; } + } } if (_GET_CURRQEST_DATATYPE() == EFI_IFR_TYPE_OTHER) { Size = sizeof (EFI_IFR_TYPE_VALUE); } else if (ArrayType) { switch (_GET_CURRQEST_DATATYPE()) { @@ -3411,11 +3710,15 @@ vfrStatementOneOfOption : break; default: break; } } else { - ReturnCode = gCVfrVarDataTypeDB.GetDataTypeSize (_GET_CURRQEST_DATATYPE(), &Size); + if (_GET_CURRQEST_VARTINFO().mIsBitVar) { + Size = sizeof (UINT32); + } else { + ReturnCode = gCVfrVarDataTypeDB.GetDataTypeSize (_GET_CURRQEST_DATATYPE(), &Size); + } } if (ReturnCode != VFR_RETURN_SUCCESS) { _PCATCH (ReturnCode, L->getLine()); } @@ -3424,11 +3727,15 @@ vfrStatementOneOfOption : OOOObj->SetLineNo(L->getLine()); OOOObj->SetOption (_STOSID(S->getText(), S->getLine())); if (ArrayType) { OOOObj->SetType (EFI_IFR_TYPE_BUFFER); } else { + if (_GET_CURRQEST_VARTINFO().mIsBitVar) { + OOOObj->SetType ( EFI_IFR_TYPE_NUM_SIZE_32); + } else { OOOObj->SetType (_GET_CURRQEST_DATATYPE()); + } } OOOObj->SetValue (*Val); >> F:FLAGS "=" vfrOneOfOptionFlags[*OOOObj, F->getLine()] << diff --git a/BaseTools/Source/C/VfrCompile/VfrUtilityLib.cpp b/BaseTools/Source/C/VfrCompile/VfrUtilityLib.cpp index 2f97975..d0b7d6c 100644 --- a/BaseTools/Source/C/VfrCompile/VfrUtilityLib.cpp +++ b/BaseTools/Source/C/VfrCompile/VfrUtilityLib.cpp @@ -1,10 +1,10 @@ /** @file Vfr common library functions. -Copyright (c) 2004 - 2016, Intel Corporation. All rights reserved.<BR> +Copyright (c) 2004 - 2017, Intel Corporation. All rights reserved.<BR> 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 @@ -575,10 +575,19 @@ CVfrVarDataTypeDB::RegisterNewType ( { New->mNext = mDataTypeList; mDataTypeList = New; } +VOID +CVfrVarDataTypeDB::RegisterNewBitsType ( + IN SVfrDataType *New + ) +{ + New->mNext = mBitsTypeList; + mBitsTypeList = New; +} + EFI_VFR_RETURN_CODE CVfrVarDataTypeDB::ExtractStructTypeName ( IN CHAR8 *&VarStr, OUT CHAR8 *TName ) @@ -598,10 +607,28 @@ CVfrVarDataTypeDB::ExtractStructTypeName ( } return VFR_RETURN_SUCCESS; } +BOOLEAN +CVfrVarDataTypeDB::DataTypeHasBitField ( + IN CHAR8 *TypeName + ) +{ + SVfrDataType *pType = NULL; + SVfrDataField *pTmp; + + GetDataType (TypeName, &pType); + for (pTmp = pType->mMembers; pTmp!= NULL; pTmp = pTmp->mNext) { + if (pTmp->mIsBitField) { + return TRUE; + } + } + return FALSE; +} + + EFI_VFR_RETURN_CODE CVfrVarDataTypeDB::ExtractFieldNameAndArrary ( IN CHAR8 *&VarStr, IN CHAR8 *FName, OUT UINT32 &ArrayIdx @@ -695,11 +722,12 @@ CVfrVarDataTypeDB::GetTypeField ( EFI_VFR_RETURN_CODE CVfrVarDataTypeDB::GetFieldOffset ( IN SVfrDataField *Field, IN UINT32 ArrayIdx, - OUT UINT32 &Offset + OUT UINT32 &Offset, + IN BOOLEAN IsBitField ) { if (Field == NULL) { return VFR_RETURN_FATAL_ERROR; } @@ -727,12 +755,15 @@ CVfrVarDataTypeDB::GetFieldOffset ( // // if ((ArrayIdx == INVALID_ARRAY_INDEX) && (Field->mArrayNum > 0)) { // return VFR_RETURN_ERROR_ARRARY_NUM; // } // - - Offset = Field->mOffset + Field->mFieldType->mTotalSize * ((ArrayIdx == INVALID_ARRAY_INDEX) ? 0 : ArrayIdx); + if (IsBitField) { + Offset = Field->mOffset + Field->mFieldType->mTotalSize * ((ArrayIdx == INVALID_ARRAY_INDEX) ? 0 : ArrayIdx) * 8; + } else { + Offset = Field->mOffset + Field->mFieldType->mTotalSize * ((ArrayIdx == INVALID_ARRAY_INDEX) ? 0 : ArrayIdx); + } return VFR_RETURN_SUCCESS; } UINT8 CVfrVarDataTypeDB::GetFieldWidth ( @@ -747,21 +778,26 @@ CVfrVarDataTypeDB::GetFieldWidth ( } UINT32 CVfrVarDataTypeDB::GetFieldSize ( IN SVfrDataField *Field, - IN UINT32 ArrayIdx + IN UINT32 ArrayIdx, + IN BOOLEAN IsBitField ) { if (Field == NULL) { return VFR_RETURN_FATAL_ERROR; } if ((ArrayIdx == INVALID_ARRAY_INDEX) && (Field->mArrayNum != 0)) { - return Field->mFieldType->mTotalSize * Field->mArrayNum; + return Field->mFieldType->mTotalSize * Field->mArrayNum; } else { - return Field->mFieldType->mTotalSize; + if (IsBitField) { + return Field->mBitWidth; + } else { + return Field->mFieldType->mTotalSize; + } } } VOID CVfrVarDataTypeDB::InternalTypesListInit ( @@ -786,22 +822,25 @@ CVfrVarDataTypeDB::InternalTypesListInit ( strcpy (pYearField->mFieldName, "Year"); GetDataType ((CHAR8 *)"UINT16", &pYearField->mFieldType); pYearField->mOffset = 0; pYearField->mNext = pMonthField; pYearField->mArrayNum = 0; + pYearField->mIsBitField = FALSE; strcpy (pMonthField->mFieldName, "Month"); GetDataType ((CHAR8 *)"UINT8", &pMonthField->mFieldType); pMonthField->mOffset = 2; pMonthField->mNext = pDayField; pMonthField->mArrayNum = 0; + pMonthField->mIsBitField = FALSE; strcpy (pDayField->mFieldName, "Day"); GetDataType ((CHAR8 *)"UINT8", &pDayField->mFieldType); pDayField->mOffset = 3; pDayField->mNext = NULL; pDayField->mArrayNum = 0; + pDayField->mIsBitField = FALSE; New->mMembers = pYearField; } else if (strcmp (gInternalTypesTable[Index].mTypeName, "EFI_HII_TIME") == 0) { SVfrDataField *pHoursField = new SVfrDataField; SVfrDataField *pMinutesField = new SVfrDataField; @@ -810,22 +849,25 @@ CVfrVarDataTypeDB::InternalTypesListInit ( strcpy (pHoursField->mFieldName, "Hours"); GetDataType ((CHAR8 *)"UINT8", &pHoursField->mFieldType); pHoursField->mOffset = 0; pHoursField->mNext = pMinutesField; pHoursField->mArrayNum = 0; + pHoursField->mIsBitField = FALSE; strcpy (pMinutesField->mFieldName, "Minutes"); GetDataType ((CHAR8 *)"UINT8", &pMinutesField->mFieldType); pMinutesField->mOffset = 1; pMinutesField->mNext = pSecondsField; pMinutesField->mArrayNum = 0; + pMinutesField->mIsBitField = FALSE; strcpy (pSecondsField->mFieldName, "Seconds"); GetDataType ((CHAR8 *)"UINT8", &pSecondsField->mFieldType); pSecondsField->mOffset = 2; pSecondsField->mNext = NULL; pSecondsField->mArrayNum = 0; + pSecondsField->mIsBitField = FALSE; New->mMembers = pHoursField; } else if (strcmp (gInternalTypesTable[Index].mTypeName, "EFI_HII_REF") == 0) { SVfrDataField *pQuestionIdField = new SVfrDataField; SVfrDataField *pFormIdField = new SVfrDataField; @@ -835,28 +877,32 @@ CVfrVarDataTypeDB::InternalTypesListInit ( strcpy (pQuestionIdField->mFieldName, "QuestionId"); GetDataType ((CHAR8 *)"UINT16", &pQuestionIdField->mFieldType); pQuestionIdField->mOffset = 0; pQuestionIdField->mNext = pFormIdField; pQuestionIdField->mArrayNum = 0; + pQuestionIdField->mIsBitField = FALSE; strcpy (pFormIdField->mFieldName, "FormId"); GetDataType ((CHAR8 *)"UINT16", &pFormIdField->mFieldType); pFormIdField->mOffset = 2; pFormIdField->mNext = pFormSetGuidField; pFormIdField->mArrayNum = 0; + pFormIdField->mIsBitField = FALSE; strcpy (pFormSetGuidField->mFieldName, "FormSetGuid"); GetDataType ((CHAR8 *)"EFI_GUID", &pFormSetGuidField->mFieldType); pFormSetGuidField->mOffset = 4; pFormSetGuidField->mNext = pDevicePathField; pFormSetGuidField->mArrayNum = 0; + pFormSetGuidField->mIsBitField = FALSE; strcpy (pDevicePathField->mFieldName, "DevicePath"); GetDataType ((CHAR8 *)"EFI_STRING_ID", &pDevicePathField->mFieldType); pDevicePathField->mOffset = 20; pDevicePathField->mNext = NULL; pDevicePathField->mArrayNum = 0; + pDevicePathField->mIsBitField = FALSE; New->mMembers = pQuestionIdField; } else { New->mMembers = NULL; } @@ -870,10 +916,11 @@ CVfrVarDataTypeDB::InternalTypesListInit ( CVfrVarDataTypeDB::CVfrVarDataTypeDB ( VOID ) { mDataTypeList = NULL; + mBitsTypeList = NULL; mNewDataType = NULL; mCurrDataField = NULL; mPackAlign = DEFAULT_PACK_ALIGN; mPackStack = NULL; mFirstNewDataTypeName = NULL; @@ -899,11 +946,22 @@ CVfrVarDataTypeDB::~CVfrVarDataTypeDB ( while(pType->mMembers != NULL) { pField = pType->mMembers; pType->mMembers = pType->mMembers->mNext; delete pField; } - delete pType; + delete pType; + } + + while (mBitsTypeList != NULL) { + pType = mBitsTypeList; + mBitsTypeList = mBitsTypeList->mNext; + while(pType->mMembers != NULL) { + pField = pType->mMembers; + pType->mMembers = pType->mMembers->mNext; + delete pField; + } + delete pType; } while (mPackStack != NULL) { pPack = mPackStack; mPackStack = mPackStack->mNext; @@ -976,10 +1034,11 @@ CVfrVarDataTypeDB::DeclareDataTypeBegin ( pNewType->mType = EFI_IFR_TYPE_OTHER; pNewType->mAlign = DEFAULT_ALIGN; pNewType->mTotalSize = 0; pNewType->mMembers = NULL; pNewType->mNext = NULL; + pNewType->mHasBitField = FALSE; mNewDataType = pNewType; } EFI_VFR_RETURN_CODE @@ -1008,10 +1067,61 @@ CVfrVarDataTypeDB::SetNewTypeName ( strcpy(mNewDataType->mTypeName, TypeName); return VFR_RETURN_SUCCESS; } EFI_VFR_RETURN_CODE +CVfrVarDataTypeDB::DataTypeAddBitField ( + IN CHAR8 *FieldName, + IN CHAR8 *TypeName, + IN UINT8 Width + ) +{ + SVfrDataField *pNewField = NULL; + SVfrDataType *pFieldType = NULL; + SVfrDataField *pTmp; + UINT32 Align; + + CHECK_ERROR_RETURN (GetDataType (TypeName, &pFieldType), VFR_RETURN_SUCCESS); + + if (strlen (FieldName) >= MAX_NAME_LEN) { + return VFR_RETURN_INVALID_PARAMETER; + } + + for (pTmp = mNewDataType->mMembers; pTmp != NULL; pTmp = pTmp->mNext) { + if (strcmp (pTmp->mFieldName, FieldName) == 0) { + return VFR_RETURN_REDEFINED; + } + } + + if ((pNewField = new SVfrDataField) == NULL) { + return VFR_RETURN_OUT_FOR_RESOURCES; + } + + strcpy (pNewField->mFieldName, FieldName); + pNewField->mFieldType = pFieldType; + pNewField->mIsBitField = TRUE; + pNewField->mBitWidth = Width; + + if (mNewDataType->mMembers == NULL) { + mNewDataType->mMembers = pNewField; + pNewField->mNext = NULL; + pNewField->mOffset = 0; + } else { + for (pTmp = mNewDataType->mMembers; pTmp->mNext != NULL; pTmp = pTmp->mNext) + ; + pTmp->mNext = pNewField; + pNewField->mNext = NULL; + } + + mNewDataType->mAlign = MIN (mPackAlign, MAX (pFieldType->mAlign, mNewDataType->mAlign)); + + mNewDataType->mHasBitField = TRUE; + + return VFR_RETURN_SUCCESS; +} + +EFI_VFR_RETURN_CODE CVfrVarDataTypeDB::DataTypeAddField ( IN CHAR8 *FieldName, IN CHAR8 *TypeName, IN UINT32 ArrayNum ) @@ -1039,10 +1149,11 @@ CVfrVarDataTypeDB::DataTypeAddField ( return VFR_RETURN_OUT_FOR_RESOURCES; } strcpy (pNewField->mFieldName, FieldName); pNewField->mFieldType = pFieldType; pNewField->mArrayNum = ArrayNum; + pNewField->mIsBitField = FALSE; if ((mNewDataType->mTotalSize % Align) == 0) { pNewField->mOffset = mNewDataType->mTotalSize; } else { pNewField->mOffset = mNewDataType->mTotalSize + ALIGN_STUFF(mNewDataType->mTotalSize, Align); } @@ -1061,20 +1172,117 @@ CVfrVarDataTypeDB::DataTypeAddField ( return VFR_RETURN_SUCCESS; } VOID +CVfrVarDataTypeDB::ChangeFieldToBitRepresentation( + IN SVfrDataType *DataType + ) +{ + + SVfrDataField *pTmp; + SVfrDataField *pSTmp; + UINT32 Offset; + UINT8 Width; + UINT32 TotalSize; + + Offset = 0; + Width = 0; + TotalSize = 0; + + + for (pTmp = DataType->mMembers; pTmp!= NULL; pTmp = pTmp->mNext) { + pTmp->mOffset = 0; + } + + for (pTmp = DataType->mMembers; pTmp != NULL; pTmp = pTmp->mNext) { + if (pTmp->mIsBitField) { + pSTmp = pTmp; + while (pSTmp != NULL && pSTmp->mIsBitField) { + pSTmp->mOffset += Offset; + pTmp = pSTmp; + if ((pSTmp->mNext != NULL) &&!(pSTmp->mNext->mIsBitField)) { + // + // Currect field is bit field, but next field is not bit field + // + if (Width > 0){ + TotalSize += pSTmp->mFieldType->mTotalSize; + Width += pSTmp->mBitWidth; + if (Width > pSTmp->mFieldType->mTotalSize * 8) { + Offset += pSTmp->mFieldType->mTotalSize * 8; + pSTmp->mOffset += Offset; + } else { + pSTmp->mOffset += (Width - pSTmp->mBitWidth); + } + Width = 0; + break; + } + Offset += pSTmp->mFieldType->mTotalSize * 8; + TotalSize += pSTmp->mFieldType->mTotalSize; + break; + } else if ((pSTmp->mNext != NULL) && strcmp (pSTmp->mFieldType->mTypeName,pSTmp->mNext->mFieldType->mTypeName) !=0) { + // + // Currect field is bit field, and next field is also bit field, + // but they have different type name. + // + if (Width > 0){ + Width += pSTmp->mBitWidth; + if (Width > pSTmp->mFieldType->mTotalSize * 8) { + Offset += pSTmp->mFieldType->mTotalSize * 8; + pSTmp->mOffset += Offset; + } else { + pSTmp->mOffset += (Width - pSTmp->mBitWidth); + } + Width = 0; + } + Offset += pSTmp->mFieldType->mTotalSize * 8; + TotalSize += pSTmp->mFieldType->mTotalSize; + break; + }else { + pSTmp->mOffset += Width; + Width += pSTmp->mBitWidth; + if (Width > pSTmp->mFieldType->mTotalSize * 8) { + Offset += pSTmp->mFieldType->mTotalSize * 8; + TotalSize += pSTmp->mFieldType->mTotalSize; + Width = 0; + break; + } + } + if (pSTmp->mNext == NULL) { + Offset += pSTmp->mFieldType->mTotalSize * 8; + TotalSize += pSTmp->mFieldType->mTotalSize; + Width = 0; + break; + } + pSTmp = pSTmp->mNext; + } + } else { + pTmp->mOffset += Offset; + pTmp->mBitWidth = pTmp->mFieldType->mTotalSize * 8; + Offset += pTmp->mFieldType->mTotalSize * 8; + TotalSize += pTmp->mFieldType->mTotalSize; + } + } + + DataType->mTotalSize = TotalSize; +} + +VOID CVfrVarDataTypeDB::DeclareDataTypeEnd ( VOID ) { if (mNewDataType->mTypeName[0] == '\0') { return; } - if ((mNewDataType->mTotalSize % mNewDataType->mAlign) !=0) { - mNewDataType->mTotalSize += ALIGN_STUFF (mNewDataType->mTotalSize, mNewDataType->mAlign); + if (mNewDataType->mHasBitField) { + ChangeFieldToBitRepresentation (mNewDataType); + } else { + if ((mNewDataType->mTotalSize % mNewDataType->mAlign) !=0) { + mNewDataType->mTotalSize += ALIGN_STUFF (mNewDataType->mTotalSize, mNewDataType->mAlign); + } } RegisterNewType (mNewDataType); if (mFirstNewDataTypeName == NULL) { mFirstNewDataTypeName = mNewDataType->mTypeName; @@ -1170,43 +1378,104 @@ CVfrVarDataTypeDB::GetDataTypeSize ( EFI_VFR_RETURN_CODE CVfrVarDataTypeDB::GetDataFieldInfo ( IN CHAR8 *VarStr, OUT UINT16 &Offset, OUT UINT8 &Type, + OUT UINT32 &Size, + IN BOOLEAN IsBitField + ) +{ + CHAR8 TName[MAX_NAME_LEN], FName[MAX_NAME_LEN]; + UINT32 ArrayIdx, Tmp; + SVfrDataType *pType = NULL; + SVfrDataField *pField = NULL; + BOOLEAN IsNestBitField; + + Offset = 0; + Type = EFI_IFR_TYPE_OTHER; + Size = 0; + + CHECK_ERROR_RETURN (ExtractStructTypeName (VarStr, TName), VFR_RETURN_SUCCESS); + CHECK_ERROR_RETURN (GetDataType (TName, &pType), VFR_RETURN_SUCCESS); + + // + // if it is not struct data type + // + Type = pType->mType; + Size = pType->mTotalSize; + + while (*VarStr != '\0') { + CHECK_ERROR_RETURN(ExtractFieldNameAndArrary(VarStr, FName, ArrayIdx), VFR_RETURN_SUCCESS); + CHECK_ERROR_RETURN(GetTypeField (FName, pType, pField), VFR_RETURN_SUCCESS); + pType = pField->mFieldType; + IsNestBitField = pField->mIsBitField; + gNestStructureIsBitVar = IsNestBitField; + if (!IsBitField && IsNestBitField) { + CHECK_ERROR_RETURN(GetFieldOffset (pField, ArrayIdx, Tmp, IsNestBitField), VFR_RETURN_SUCCESS); + Offset = (UINT16) (Offset * 8 + Tmp); + Size = GetFieldSize (pField, ArrayIdx, IsNestBitField); + } else { + CHECK_ERROR_RETURN(GetFieldOffset (pField, ArrayIdx, Tmp, IsBitField), VFR_RETURN_SUCCESS); + Offset = (UINT16) (Offset + Tmp); + Size = GetFieldSize (pField, ArrayIdx, IsBitField); + } + Type = GetFieldWidth (pField); + } + return VFR_RETURN_SUCCESS; +} + +EFI_VFR_RETURN_CODE +CVfrVarDataTypeDB::GetDataFieldInfo ( + IN CHAR8 *VarStr, + OUT UINT16 &Offset, + OUT UINT8 &Type, OUT UINT32 &Size ) { CHAR8 TName[MAX_NAME_LEN], FName[MAX_NAME_LEN]; UINT32 ArrayIdx, Tmp; SVfrDataType *pType = NULL; SVfrDataField *pField = NULL; + BOOLEAN IsNestBitField; + BOOLEAN IsBitField; Offset = 0; Type = EFI_IFR_TYPE_OTHER; Size = 0; CHECK_ERROR_RETURN (ExtractStructTypeName (VarStr, TName), VFR_RETURN_SUCCESS); CHECK_ERROR_RETURN (GetDataType (TName, &pType), VFR_RETURN_SUCCESS); + IsBitField = DataTypeHasBitField (TName); + // // if it is not struct data type // Type = pType->mType; Size = pType->mTotalSize; while (*VarStr != '\0') { - CHECK_ERROR_RETURN(ExtractFieldNameAndArrary(VarStr, FName, ArrayIdx), VFR_RETURN_SUCCESS); + CHECK_ERROR_RETURN(ExtractFieldNameAndArrary(VarStr, FName, ArrayIdx), VFR_RETURN_SUCCESS); CHECK_ERROR_RETURN(GetTypeField (FName, pType, pField), VFR_RETURN_SUCCESS); pType = pField->mFieldType; - CHECK_ERROR_RETURN(GetFieldOffset (pField, ArrayIdx, Tmp), VFR_RETURN_SUCCESS); - Offset = (UINT16) (Offset + Tmp); + IsNestBitField = pField->mIsBitField; + gNestStructureIsBitVar = IsNestBitField; + if (!IsBitField && IsNestBitField) { + CHECK_ERROR_RETURN(GetFieldOffset (pField, ArrayIdx, Tmp, IsNestBitField), VFR_RETURN_SUCCESS); + Offset = (UINT16) (Offset * 8 + Tmp); + Size = GetFieldSize (pField, ArrayIdx, IsNestBitField); + } else { + CHECK_ERROR_RETURN(GetFieldOffset (pField, ArrayIdx, Tmp, IsBitField), VFR_RETURN_SUCCESS); + Offset = (UINT16) (Offset + Tmp); + Size = GetFieldSize (pField, ArrayIdx, IsBitField); + } Type = GetFieldWidth (pField); - Size = GetFieldSize (pField, ArrayIdx); } return VFR_RETURN_SUCCESS; } + EFI_VFR_RETURN_CODE CVfrVarDataTypeDB::GetUserDefinedTypeNameList ( OUT CHAR8 ***NameList, OUT UINT32 *ListSize ) @@ -1347,10 +1616,11 @@ SVfrVarStorageNode::SVfrVarStorageNode ( SVfrVarStorageNode::SVfrVarStorageNode ( IN EFI_GUID *Guid, IN CHAR8 *StoreName, IN EFI_VARSTORE_ID VarStoreId, IN SVfrDataType *DataType, + IN BOOLEAN BitsVarstore, IN BOOLEAN Flag ) { if (Guid != NULL) { mGuid = *Guid; @@ -1363,11 +1633,15 @@ SVfrVarStorageNode::SVfrVarStorageNode ( } else { mVarStoreName = NULL; } mNext = NULL; mVarStoreId = VarStoreId; - mVarStoreType = EFI_VFR_VARSTORE_BUFFER; + if (BitsVarstore) { + mVarStoreType = EFI_VFR_VARSTORE_BUFFER_BITS; + } else { + mVarStoreType = EFI_VFR_VARSTORE_BUFFER; + } mStorageInfo.mDataType = DataType; mAssignedFlag = Flag; } SVfrVarStorageNode::SVfrVarStorageNode ( @@ -1415,10 +1689,11 @@ CVfrDataStorage::CVfrDataStorage ( mFreeVarStoreIdBitMap[0] = 0x80000000; mBufferVarStoreList = NULL; mEfiVarStoreList = NULL; mNameVarStoreList = NULL; + mBitsBufferStoreList = NULL; mCurrVarStorageNode = NULL; mNewVarStorageNode = NULL; mBufferFieldInfoListHead = NULL; mBufferFieldInfoListTail = NULL; } @@ -1442,10 +1717,15 @@ CVfrDataStorage::~CVfrDataStorage ( while (mNameVarStoreList != NULL) { pNode = mNameVarStoreList; mNameVarStoreList = mNameVarStoreList->mNext; delete pNode; } + while ( mBitsBufferStoreList != NULL) { + pNode = mBitsBufferStoreList; + mBitsBufferStoreList = mBitsBufferStoreList->mNext; + delete pNode; + } if (mNewVarStorageNode != NULL) { delete mNewVarStorageNode; } } @@ -1661,11 +1941,11 @@ CVfrDataStorage::DeclareBufferVarStore ( return VFR_RETURN_VARSTOREID_REDEFINED; } MarkVarStoreIdUsed (VarStoreId); } - if ((pNew = new SVfrVarStorageNode (Guid, StoreName, VarStoreId, pDataType, Flag)) == NULL) { + if ((pNew = new SVfrVarStorageNode (Guid, StoreName, VarStoreId, pDataType, FALSE, Flag)) == NULL) { return VFR_RETURN_OUT_FOR_RESOURCES; } pNew->mNext = mBufferVarStoreList; mBufferVarStoreList = pNew; @@ -1676,10 +1956,57 @@ CVfrDataStorage::DeclareBufferVarStore ( return VFR_RETURN_SUCCESS; } EFI_VFR_RETURN_CODE +CVfrDataStorage::DeclareBitsBufferVarStore ( + IN CHAR8 *StoreName, + IN EFI_GUID *Guid, + IN CVfrVarDataTypeDB *DataTypeDB, + IN CHAR8 *TypeName, + IN EFI_VARSTORE_ID VarStoreId, + IN BOOLEAN Flag + ) +{ + SVfrVarStorageNode *pNew = NULL; + SVfrDataType *pDataType = NULL; + EFI_VARSTORE_ID TempVarStoreId; + + if ((StoreName == NULL) || (Guid == NULL) || (DataTypeDB == NULL)) { + return VFR_RETURN_FATAL_ERROR; + } + + if (GetVarStoreId (StoreName, &TempVarStoreId, Guid) == VFR_RETURN_SUCCESS) { + return VFR_RETURN_REDEFINED; + } + + CHECK_ERROR_RETURN(DataTypeDB->GetDataType (TypeName, &pDataType), VFR_RETURN_SUCCESS); + + if (VarStoreId == EFI_VARSTORE_ID_INVALID) { + VarStoreId = GetFreeVarStoreId (EFI_VFR_VARSTORE_BUFFER); + } else { + if (ChekVarStoreIdFree (VarStoreId) == FALSE) { + return VFR_RETURN_VARSTOREID_REDEFINED; + } + MarkVarStoreIdUsed (VarStoreId); + } + + if ((pNew = new SVfrVarStorageNode (Guid, StoreName, VarStoreId, pDataType, TRUE, Flag)) == NULL) { + return VFR_RETURN_OUT_FOR_RESOURCES; + } + + pNew->mNext = mBitsBufferStoreList; + mBitsBufferStoreList = pNew; + + if (gCVfrBufferConfig.Register(StoreName, Guid) != 0) { + return VFR_RETURN_FATAL_ERROR; + } + + return VFR_RETURN_SUCCESS; +} + +EFI_VFR_RETURN_CODE CVfrDataStorage::GetVarStoreByDataType ( IN CHAR8 *DataTypeName, OUT SVfrVarStorageNode **VarNode, IN EFI_GUID *VarGuid ) @@ -1813,10 +2140,18 @@ CVfrDataStorage::GetVarStoreId ( *VarStoreId = mCurrVarStorageNode->mVarStoreId; return ReturnCode; } } } + for (pNode = mBitsBufferStoreList; pNode != NULL; pNode = pNode->mNext) { + if (strcmp (pNode->mVarStoreName, StoreName) == 0) { + if (CheckGuidField(pNode, StoreGuid, &HasFoundOne, &ReturnCode)) { + *VarStoreId = mCurrVarStorageNode->mVarStoreId; + return ReturnCode; + } + } + } if (HasFoundOne) { *VarStoreId = mCurrVarStorageNode->mVarStoreId; return VFR_RETURN_SUCCESS; } @@ -1852,10 +2187,17 @@ CVfrDataStorage::GetBufferVarStoreDataTypeName ( *DataTypeName = pNode->mStorageInfo.mDataType->mTypeName; return VFR_RETURN_SUCCESS; } } + for (pNode = mBitsBufferStoreList; pNode != NULL; pNode = pNode->mNext) { + if (pNode->mVarStoreId == VarStoreId) { + *DataTypeName = pNode->mStorageInfo.mDataType->mTypeName; + return VFR_RETURN_SUCCESS; + } + } + return VFR_RETURN_UNDEFINED; } EFI_VFR_VARSTORE_TYPE CVfrDataStorage::GetVarStoreType ( @@ -1890,10 +2232,17 @@ CVfrDataStorage::GetVarStoreType ( VarStoreType = pNode->mVarStoreType; return VarStoreType; } } + for (pNode = mBitsBufferStoreList; pNode != NULL; pNode = pNode->mNext) { + if (pNode->mVarStoreId == VarStoreId) { + VarStoreType = pNode->mVarStoreType; + return VarStoreType; + } + } + return VarStoreType; } EFI_GUID * CVfrDataStorage::GetVarStoreGuid ( @@ -1928,10 +2277,17 @@ CVfrDataStorage::GetVarStoreGuid ( VarGuid = &pNode->mGuid; return VarGuid; } } + for (pNode = mBitsBufferStoreList; pNode != NULL; pNode = pNode->mNext) { + if (pNode->mVarStoreId == VarStoreId) { + VarGuid = &pNode->mGuid; + return VarGuid; + } + } + return VarGuid; } EFI_VFR_RETURN_CODE CVfrDataStorage::GetVarStoreName ( @@ -1964,10 +2320,18 @@ CVfrDataStorage::GetVarStoreName ( *VarStoreName = pNode->mVarStoreName; return VFR_RETURN_SUCCESS; } } + for (pNode = mBitsBufferStoreList; pNode != NULL; pNode = pNode->mNext) { + if (pNode->mVarStoreId == VarStoreId) { + *VarStoreName = pNode->mVarStoreName; + return VFR_RETURN_SUCCESS; + } + } + + *VarStoreName = NULL; return VFR_RETURN_UNDEFINED; } EFI_VFR_RETURN_CODE @@ -2375,10 +2739,11 @@ EFI_VARSTORE_INFO::EFI_VARSTORE_INFO ( mVarStoreId = EFI_VARSTORE_ID_INVALID; mInfo.mVarName = EFI_STRING_ID_INVALID; mInfo.mVarOffset = EFI_VAROFFSET_INVALID; mVarType = EFI_IFR_TYPE_OTHER; mVarTotalSize = 0; + mIsBitVar = FALSE; } EFI_VARSTORE_INFO::EFI_VARSTORE_INFO ( IN EFI_VARSTORE_INFO &Info ) @@ -2386,10 +2751,11 @@ EFI_VARSTORE_INFO::EFI_VARSTORE_INFO ( mVarStoreId = Info.mVarStoreId; mInfo.mVarName = Info.mInfo.mVarName; mInfo.mVarOffset = Info.mInfo.mVarOffset; mVarType = Info.mVarType; mVarTotalSize = Info.mVarTotalSize; + mIsBitVar = Info.mIsBitVar; } EFI_VARSTORE_INFO& EFI_VARSTORE_INFO::operator= ( IN CONST EFI_VARSTORE_INFO &Info @@ -2399,10 +2765,11 @@ EFI_VARSTORE_INFO::operator= ( mVarStoreId = Info.mVarStoreId; mInfo.mVarName = Info.mInfo.mVarName; mInfo.mVarOffset = Info.mInfo.mVarOffset; mVarType = Info.mVarType; mVarTotalSize = Info.mVarTotalSize; + mIsBitVar = Info.mIsBitVar; } return *this; } @@ -2413,11 +2780,12 @@ EFI_VARSTORE_INFO::operator == ( { if ((mVarStoreId == Info->mVarStoreId) && (mInfo.mVarName == Info->mInfo.mVarName) && (mInfo.mVarOffset == Info->mInfo.mVarOffset) && (mVarType == Info->mVarType) && - (mVarTotalSize == Info->mVarTotalSize)) { + (mVarTotalSize == Info->mVarTotalSize) && + (mIsBitVar == Info->mIsBitVar)) { return TRUE; } return FALSE; } @@ -3715,11 +4083,13 @@ CVfrStringDB::GetUnicodeStringTextSize ( } return StringSize; } -BOOLEAN VfrCompatibleMode = FALSE; +BOOLEAN VfrCompatibleMode = FALSE; +BOOLEAN gNestStructureIsBitVar = FALSE; +EFI_GUID gBitVarstoreGuid = {0x82DDD68B, 0x9163, 0x4187, {0x9B, 0x27, 0x20, 0xA8, 0xFD, 0x60 ,0xA7 , 0x1D}}; CVfrVarDataTypeDB gCVfrVarDataTypeDB; CVfrDefaultStore gCVfrDefaultStore; CVfrDataStorage gCVfrDataStorage; diff --git a/BaseTools/Source/C/VfrCompile/VfrUtilityLib.h b/BaseTools/Source/C/VfrCompile/VfrUtilityLib.h index 59509c3..2adfba7 100644 --- a/BaseTools/Source/C/VfrCompile/VfrUtilityLib.h +++ b/BaseTools/Source/C/VfrCompile/VfrUtilityLib.h @@ -1,10 +1,10 @@ /** @file Vfr common library functions. -Copyright (c) 2004 - 2016, Intel Corporation. All rights reserved.<BR> +Copyright (c) 2004 - 2017, Intel Corporation. All rights reserved.<BR> 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 @@ -20,10 +20,12 @@ WITHOUT WARRANTIES OR REPRESENTATIONS OF ANY KIND, EITHER EXPRESS OR IMPLIED. #include "Common/UefiBaseTypes.h" #include "EfiVfr.h" #include "VfrError.h" extern BOOLEAN VfrCompatibleMode; +extern EFI_GUID gBitVarstoreGuid; +extern BOOLEAN gNestStructureIsBitVar; #define MAX_NAME_LEN 64 #define MAX_STRING_LEN 0x100 #define DEFAULT_ALIGN 1 #define DEFAULT_PACK_ALIGN 0x8 @@ -114,18 +116,21 @@ struct SVfrDataType; struct SVfrDataField { CHAR8 mFieldName[MAX_NAME_LEN]; SVfrDataType *mFieldType; UINT32 mOffset; UINT32 mArrayNum; + BOOLEAN mIsBitField; + UINT8 mBitWidth; SVfrDataField *mNext; }; struct SVfrDataType { CHAR8 mTypeName[MAX_NAME_LEN]; UINT8 mType; UINT32 mAlign; UINT32 mTotalSize; + BOOLEAN mHasBitField; SVfrDataField *mMembers; SVfrDataType *mNext; }; #define VFR_PACK_ASSIGN 0x01 @@ -183,40 +188,46 @@ private: public: EFI_VFR_RETURN_CODE Pack (IN UINT32, IN UINT8, IN CHAR8 *Identifier = NULL, IN UINT32 Number = DEFAULT_PACK_ALIGN); private: SVfrDataType *mDataTypeList; + SVfrDataType *mBitsTypeList; SVfrDataType *mNewDataType; SVfrDataType *mCurrDataType; SVfrDataField *mCurrDataField; VOID InternalTypesListInit (VOID); VOID RegisterNewType (IN SVfrDataType *); + VOID RegisterNewBitsType (IN SVfrDataType *); EFI_VFR_RETURN_CODE ExtractStructTypeName (IN CHAR8 *&, OUT CHAR8 *); EFI_VFR_RETURN_CODE GetTypeField (IN CONST CHAR8 *, IN SVfrDataType *, IN SVfrDataField *&); - EFI_VFR_RETURN_CODE GetFieldOffset (IN SVfrDataField *, IN UINT32, OUT UINT32 &); + EFI_VFR_RETURN_CODE GetFieldOffset (IN SVfrDataField *, IN UINT32, OUT UINT32 &, IN BOOLEAN); UINT8 GetFieldWidth (IN SVfrDataField *); - UINT32 GetFieldSize (IN SVfrDataField *, IN UINT32); + UINT32 GetFieldSize (IN SVfrDataField *, IN UINT32, IN BOOLEAN); public: CVfrVarDataTypeDB (VOID); ~CVfrVarDataTypeDB (VOID); VOID DeclareDataTypeBegin (VOID); EFI_VFR_RETURN_CODE SetNewTypeName (IN CHAR8 *); EFI_VFR_RETURN_CODE DataTypeAddField (IN CHAR8 *, IN CHAR8 *, IN UINT32); + EFI_VFR_RETURN_CODE DataTypeAddBitField (IN CHAR8 *, IN CHAR8 *, IN UINT8); VOID DeclareDataTypeEnd (VOID); + VOID ChangeFieldToBitRepresentation( IN SVfrDataType *); EFI_VFR_RETURN_CODE GetDataType (IN CHAR8 *, OUT SVfrDataType **); EFI_VFR_RETURN_CODE GetDataTypeSize (IN CHAR8 *, OUT UINT32 *); EFI_VFR_RETURN_CODE GetDataTypeSize (IN UINT8, OUT UINT32 *); + EFI_VFR_RETURN_CODE GetDataFieldInfo (IN CHAR8 *, OUT UINT16 &, OUT UINT8 &, OUT UINT32 &, IN BOOLEAN); EFI_VFR_RETURN_CODE GetDataFieldInfo (IN CHAR8 *, OUT UINT16 &, OUT UINT8 &, OUT UINT32 &); EFI_VFR_RETURN_CODE GetUserDefinedTypeNameList (OUT CHAR8 ***, OUT UINT32 *); EFI_VFR_RETURN_CODE ExtractFieldNameAndArrary (IN CHAR8 *&, OUT CHAR8 *, OUT UINT32 &); + BOOLEAN DataTypeHasBitField (IN CHAR8 *); BOOLEAN IsTypeNameDefined (IN CHAR8 *); VOID Dump(IN FILE *); // @@ -236,11 +247,12 @@ extern CVfrVarDataTypeDB gCVfrVarDataTypeDB; typedef enum { EFI_VFR_VARSTORE_INVALID, EFI_VFR_VARSTORE_BUFFER, EFI_VFR_VARSTORE_EFI, - EFI_VFR_VARSTORE_NAME + EFI_VFR_VARSTORE_NAME, + EFI_VFR_VARSTORE_BUFFER_BITS } EFI_VFR_VARSTORE_TYPE; struct SVfrVarStorageNode { EFI_GUID mGuid; CHAR8 *mVarStoreName; @@ -266,11 +278,11 @@ struct SVfrVarStorageNode { } mNameSpace; } mStorageInfo; public: SVfrVarStorageNode (IN EFI_GUID *, IN CHAR8 *, IN EFI_VARSTORE_ID, IN EFI_STRING_ID, IN UINT32, IN BOOLEAN Flag = TRUE); - SVfrVarStorageNode (IN EFI_GUID *, IN CHAR8 *, IN EFI_VARSTORE_ID, IN SVfrDataType *, IN BOOLEAN Flag = TRUE); + SVfrVarStorageNode (IN EFI_GUID *, IN CHAR8 *, IN EFI_VARSTORE_ID, IN SVfrDataType *,IN BOOLEAN, IN BOOLEAN Flag = TRUE); SVfrVarStorageNode (IN CHAR8 *, IN EFI_VARSTORE_ID); ~SVfrVarStorageNode (VOID); private: SVfrVarStorageNode (IN CONST SVfrVarStorageNode&); // Prevent copy-construction @@ -283,10 +295,11 @@ struct EFI_VARSTORE_INFO { EFI_STRING_ID mVarName; UINT16 mVarOffset; } mInfo; UINT8 mVarType; UINT32 mVarTotalSize; + BOOLEAN mIsBitVar; EFI_VARSTORE_INFO (VOID); EFI_VARSTORE_INFO (IN EFI_VARSTORE_INFO &); EFI_VARSTORE_INFO& operator=(IN CONST EFI_VARSTORE_INFO &); BOOLEAN operator == (IN EFI_VARSTORE_INFO *); @@ -308,10 +321,11 @@ private: UINT32 mFreeVarStoreIdBitMap[EFI_FREE_VARSTORE_ID_BITMAP_SIZE]; struct SVfrVarStorageNode *mBufferVarStoreList; struct SVfrVarStorageNode *mEfiVarStoreList; struct SVfrVarStorageNode *mNameVarStoreList; + struct SVfrVarStorageNode *mBitsBufferStoreList; struct SVfrVarStorageNode *mCurrVarStorageNode; struct SVfrVarStorageNode *mNewVarStorageNode; BufferVarStoreFieldInfoNode *mBufferFieldInfoListHead; BufferVarStoreFieldInfoNode *mBufferFieldInfoListTail; @@ -342,10 +356,11 @@ public: EFI_VFR_RETURN_CODE DeclareNameVarStoreEnd (EFI_GUID *); EFI_VFR_RETURN_CODE DeclareEfiVarStore (IN CHAR8 *, IN EFI_GUID *, IN EFI_STRING_ID, IN UINT32, IN BOOLEAN Flag = TRUE); EFI_VFR_RETURN_CODE DeclareBufferVarStore (IN CHAR8 *, IN EFI_GUID *, IN CVfrVarDataTypeDB *, IN CHAR8 *, IN EFI_VARSTORE_ID, IN BOOLEAN Flag = TRUE); + EFI_VFR_RETURN_CODE DeclareBitsBufferVarStore (IN CHAR8 *, IN EFI_GUID *, IN CVfrVarDataTypeDB *, IN CHAR8 *, IN EFI_VARSTORE_ID, IN BOOLEAN Flag = TRUE); EFI_VFR_RETURN_CODE GetVarStoreId (IN CHAR8 *, OUT EFI_VARSTORE_ID *, IN EFI_GUID *VarGuid = NULL); EFI_VFR_VARSTORE_TYPE GetVarStoreType (IN EFI_VARSTORE_ID); EFI_GUID * GetVarStoreGuid (IN EFI_VARSTORE_ID); EFI_VFR_RETURN_CODE GetVarStoreName (IN EFI_VARSTORE_ID, OUT CHAR8 **); -- 1.9.5.msysgit.1 _______________________________________________ edk2-devel mailing list edk2-devel@lists.01.org https://lists.01.org/mailman/listinfo/edk2-devel
