From: "Gao, Liming" <liming.gao@intel.com>
To: "Bi, Dandan" <dandan.bi@intel.com>,
"edk2-devel@lists.01.org" <edk2-devel@lists.01.org>
Cc: "Dong, Eric" <eric.dong@intel.com>
Subject: Re: [PATCH V7 1/6] BaseTool/VfrCompiler: Support Bit fields in EFI/Buffer VarStore
Date: Thu, 21 Sep 2017 07:29:56 +0000 [thread overview]
Message-ID: <4A89E2EF3DFEDB4C8BFDE51014F606A14E15BA3B@SHSMSX152.ccr.corp.intel.com> (raw)
In-Reply-To: <1505978459-434440-1-git-send-email-dandan.bi@intel.com>
Reviewed-by: Liming Gao <liming.gao@intel.com>
>-----Original Message-----
>From: Bi, Dandan
>Sent: Thursday, September 21, 2017 3:21 PM
>To: edk2-devel@lists.01.org
>Cc: Dong, Eric <eric.dong@intel.com>; Gao, Liming <liming.gao@intel.com>
>Subject: [PATCH V7 1/6] BaseTool/VfrCompiler: Support Bit fields in EFI/Buffer
>VarStore
>
>V7: Fix GCC warning and error in VfrCompiler.
>V6: Update EDKII extenstion MACRO name with EDKII prefix
>which are missing in V5.
>
>REF: https://bugzilla.tianocore.org/show_bug.cgi?id=545
>
>Enhance VfrCompiler to parse following case:
>1. EFI/Buffer VarStore can contain bit fields in their structure.
>2. For question Oneof/Checkbox/numeric, their storage can be
> bit fields of an EFI VarStore/Buffer VarStore.
>
>Cc: Eric Dong <eric.dong@intel.com>
>Cc: Liming Gao <liming.gao@intel.com>
>Contributed-under: TianoCore Contribution Agreement 1.1
>Signed-off-by: Dandan Bi <dandan.bi@intel.com>
>---
> BaseTools/Source/C/Include/Common/MdeModuleHii.h | 20 +-
> BaseTools/Source/C/VfrCompile/VfrError.cpp | 3 +-
> BaseTools/Source/C/VfrCompile/VfrError.h | 3 +-
> BaseTools/Source/C/VfrCompile/VfrFormPkg.cpp | 105 +-
> BaseTools/Source/C/VfrCompile/VfrFormPkg.h | 52 +-
> BaseTools/Source/C/VfrCompile/VfrSyntax.g | 1238 ++++++++++++++----
>----
> BaseTools/Source/C/VfrCompile/VfrUtilityLib.cpp | 242 ++++-
> BaseTools/Source/C/VfrCompile/VfrUtilityLib.h | 23 +-
> 8 files changed, 1196 insertions(+), 490 deletions(-)
>
>diff --git a/BaseTools/Source/C/Include/Common/MdeModuleHii.h
>b/BaseTools/Source/C/Include/Common/MdeModuleHii.h
>index 21c8387..e6538e2 100644
>--- a/BaseTools/Source/C/Include/Common/MdeModuleHii.h
>+++ b/BaseTools/Source/C/Include/Common/MdeModuleHii.h
>@@ -1,9 +1,9 @@
> /** @file
> EDK II specific HII relative definition.
>
>- Copyright (c) 2006 - 2014, Intel Corporation. All rights reserved.<BR>
>+ Copyright (c) 2006 - 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
>@@ -210,12 +210,30 @@ typedef struct _EFI_IFR_GUID_VAREQNAME {
> /// The the Unicode String will be used as a EFI Variable Name.
> ///
> UINT16 NameId;
> } EFI_IFR_GUID_VAREQNAME;
>
>+///
>+/// EDKII implementation extension GUID, used to indaicate there are bit
>fields in the varstore.
>+///
>+#define EDKII_IFR_BIT_VARSTORE_GUID \
>+ { 0x82DDD68B, 0x9163, 0x4187, {0x9B, 0x27, 0x20, 0xA8, 0xFD, 0x60 ,0xA7,
>0x1D}}
>+
>+///
>+/// EDKII implementation extension flags, used to indaicate the disply style
>and bit width for bit filed storage.
>+/// Two high bits for display style and the low six bits for bit width.
>+///
>+#define EDKII_IFR_DISPLAY_BIT 0xC0
>+#define EDKII_IFR_DISPLAY_INT_DEC_BIT 0x00
>+#define EDKII_IFR_DISPLAY_UINT_DEC_BIT 0x40
>+#define EDKII_IFR_DISPLAY_UINT_HEX_BIT 0x80
>+
>+#define EDKII_IFR_NUMERIC_SIZE_BIT 0x3F
>+
> #pragma pack()
>
> extern EFI_GUID gEfiIfrTianoGuid;
> extern EFI_GUID gEfiIfrFrameworkGuid;
>+extern EFI_GUID gEdkiiIfrBitVarStoreGuid;
>
> #endif
>
>diff --git a/BaseTools/Source/C/VfrCompile/VfrError.cpp
>b/BaseTools/Source/C/VfrCompile/VfrError.cpp
>index 285e175..0f8f7dd 100644
>--- a/BaseTools/Source/C/VfrCompile/VfrError.cpp
>+++ b/BaseTools/Source/C/VfrCompile/VfrError.cpp
>@@ -1,10 +1,10 @@
> /** @file
>
> VfrCompiler error handler.
>
>-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
>
>@@ -44,10 +44,11 @@ static SVFR_ERROR_HANDLE
>VFR_ERROR_HANDLE_TABLE [] = {
> { VFR_RETURN_ERROR_ARRARY_NUM, ": array number error, the valid
>value is in (0 ~ MAX_INDEX-1) for UEFI vfr and in (1 ~ MAX_INDEX) for
>Framework Vfr" },
> { VFR_RETURN_DATA_STRING_ERROR, ": data field string error or not
>support"},
> { VFR_RETURN_DEFAULT_VALUE_REDEFINED, ": default value re-defined
>with different value"},
> { VFR_RETURN_CONSTANT_ONLY, ": only constant is allowed in the
>expression"},
> { VFR_RETURN_VARSTORE_NAME_REDEFINED_ERROR, ": Varstore name is
>defined by more than one varstores, it can't be referred as varstore, only
>varstore strucure name could be used."},
>+ { VFR_RETURN_BIT_WIDTH_ERROR, ": bit width must be <= sizeof (type) *
>8 and the max width can not > 32" },
> { VFR_RETURN_CODEUNDEFINED, ": undefined Error Code" }
> };
>
> static SVFR_WARNING_HANDLE VFR_WARNING_HANDLE_TABLE [] = {
> { VFR_WARNING_DEFAULT_VALUE_REDEFINED, ": default value re-defined
>with different value"},
>diff --git a/BaseTools/Source/C/VfrCompile/VfrError.h
>b/BaseTools/Source/C/VfrCompile/VfrError.h
>index 4dbc54c..8bae049 100644
>--- a/BaseTools/Source/C/VfrCompile/VfrError.h
>+++ b/BaseTools/Source/C/VfrCompile/VfrError.h
>@@ -1,10 +1,10 @@
> /** @file
>
> VfrCompiler Error definition
>
>-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
>
>@@ -42,10 +42,11 @@ typedef enum {
> VFR_RETURN_ERROR_ARRARY_NUM,
> VFR_RETURN_DATA_STRING_ERROR,
> VFR_RETURN_DEFAULT_VALUE_REDEFINED,
> VFR_RETURN_CONSTANT_ONLY,
> VFR_RETURN_VARSTORE_NAME_REDEFINED_ERROR,
>+ VFR_RETURN_BIT_WIDTH_ERROR,
> VFR_RETURN_CODEUNDEFINED
> } EFI_VFR_RETURN_CODE;
>
> typedef enum {
> VFR_WARNING_DEFAULT_VALUE_REDEFINED = 0,
>diff --git a/BaseTools/Source/C/VfrCompile/VfrFormPkg.cpp
>b/BaseTools/Source/C/VfrCompile/VfrFormPkg.cpp
>index 2be0c38..b835062 100644
>--- a/BaseTools/Source/C/VfrCompile/VfrFormPkg.cpp
>+++ b/BaseTools/Source/C/VfrCompile/VfrFormPkg.cpp
>@@ -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
>
>@@ -827,10 +827,13 @@ CFormPkg::DeclarePendingQuestion (
> CHAR8 *SName;
> CHAR8 *NewStr;
> UINT32 ShrinkSize = 0;
> EFI_VFR_RETURN_CODE ReturnCode;
> EFI_VFR_VARSTORE_TYPE VarStoreType = EFI_VFR_VARSTORE_INVALID;
>+ UINT8 LFlags;
>+ UINT32 MaxValue;
>+ CIfrGuid *GuidObj = NULL;
>
> //
> // Declare all questions as Numeric in DisableIf True
> //
> // DisableIf
>@@ -842,18 +845,12 @@ CFormPkg::DeclarePendingQuestion (
> CIfrTrue TObj (LineNo);
>
> // Declare Numeric qeustion for each undefined question.
> for (pNode = PendingAssignList; pNode != NULL; pNode = pNode->mNext) {
> if (pNode->mFlag == PENDING) {
>- CIfrNumeric CNObj;
> EFI_VARSTORE_INFO Info;
> EFI_QUESTION_ID QId = EFI_QUESTION_ID_INVALID;
>-
>- CNObj.SetLineNo (LineNo);
>- CNObj.SetPrompt (0x0);
>- CNObj.SetHelp (0x0);
>-
> //
> // Register this question, assume it is normal question, not date or time
>question
> //
> VarStr = pNode->mKey;
> ReturnCode = lCVfrQuestionDB.RegisterQuestion (NULL, VarStr, QId);
>@@ -886,63 +883,87 @@ CFormPkg::DeclarePendingQuestion (
> if (*VarStr == '\0' && ArrayIdx != INVALID_ARRAY_INDEX) {
> ReturnCode = lCVfrDataStorage.GetNameVarStoreInfo (&Info, ArrayIdx);
> } else {
> if (VarStoreType == EFI_VFR_VARSTORE_EFI) {
> ReturnCode = lCVfrDataStorage.GetEfiVarStoreInfo (&Info);
>- } else if (VarStoreType == EFI_VFR_VARSTORE_BUFFER) {
>+ } else if (VarStoreType == EFI_VFR_VARSTORE_BUFFER || VarStoreType
>== EFI_VFR_VARSTORE_BUFFER_BITS) {
> VarStr = pNode->mKey;
> //convert VarStr with store name to VarStr with structure name
> ReturnCode = lCVfrDataStorage.GetBufferVarStoreDataTypeName
>(Info.mVarStoreId, &SName);
> if (ReturnCode == VFR_RETURN_SUCCESS) {
> NewStr = new CHAR8[strlen (VarStr) + strlen (SName) + 1];
> NewStr[0] = '\0';
> strcpy (NewStr, SName);
> strcat (NewStr, VarStr + strlen (FName));
>- ReturnCode = lCVfrVarDataTypeDB.GetDataFieldInfo (NewStr,
>Info.mInfo.mVarOffset, Info.mVarType, Info.mVarTotalSize);
>+ ReturnCode = lCVfrVarDataTypeDB.GetDataFieldInfo (NewStr,
>Info.mInfo.mVarOffset, Info.mVarType, Info.mVarTotalSize, Info.mIsBitVar);
> delete[] NewStr;
> }
> } else {
> ReturnCode = VFR_RETURN_UNSUPPORTED;
> }
> }
> if (ReturnCode != VFR_RETURN_SUCCESS) {
> gCVfrErrorHandle.HandleError (ReturnCode, pNode->mLineNo, pNode-
>>mKey);
> return ReturnCode;
> }
>-
>- CNObj.SetQuestionId (QId);
>- CNObj.SetVarStoreInfo (&Info);
> //
>- // Numeric doesn't support BOOLEAN data type.
>- // BOOLEAN type has the same data size to UINT8.
>+ // If the storage is bit fields, create Guid opcode to wrap the numeric
>opcode.
> //
>- if (Info.mVarType == EFI_IFR_TYPE_BOOLEAN) {
>- Info.mVarType = EFI_IFR_TYPE_NUM_SIZE_8;
>+ if (Info.mIsBitVar) {
>+ GuidObj = new CIfrGuid(0);
>+ GuidObj->SetGuid (&gEdkiiIfrBitVarGuid);
>+ GuidObj->SetLineNo(LineNo);
> }
>- CNObj.SetFlags (0, Info.mVarType);
>+
>+ CIfrNumeric CNObj;
>+ CNObj.SetLineNo (LineNo);
>+ CNObj.SetPrompt (0x0);
>+ CNObj.SetHelp (0x0);
>+ CNObj.SetQuestionId (QId);
>+ CNObj.SetVarStoreInfo (&Info);
>+
> //
>- // Use maximum value not to limit the vaild value for the undefined
>question.
>+ // Set Min/Max/Step Data and flags for the question with bit
>fields.Min/Max/Step Data are saved as UINT32 type for bit question.
> //
>- switch (Info.mVarType) {
>- case EFI_IFR_TYPE_NUM_SIZE_64:
>- CNObj.SetMinMaxStepData ((UINT64) 0, (UINT64) -1 , (UINT64) 0);
>- ShrinkSize = 0;
>- break;
>- case EFI_IFR_TYPE_NUM_SIZE_32:
>- CNObj.SetMinMaxStepData ((UINT32) 0, (UINT32) -1 , (UINT32) 0);
>+ if (Info.mIsBitVar) {
>+ MaxValue = (1 << Info.mVarTotalSize) -1;
>+ CNObj.SetMinMaxStepData ((UINT32) 0, MaxValue, (UINT32) 0);
> ShrinkSize = 12;
>- break;
>- case EFI_IFR_TYPE_NUM_SIZE_16:
>- CNObj.SetMinMaxStepData ((UINT16) 0, (UINT16) -1 , (UINT16) 0);
>- ShrinkSize = 18;
>- break;
>- case EFI_IFR_TYPE_NUM_SIZE_8:
>- CNObj.SetMinMaxStepData ((UINT8) 0, (UINT8) -1 , (UINT8) 0);
>- ShrinkSize = 21;
>- break;
>- default:
>- break;
>+ LFlags = (EDKII_IFR_NUMERIC_SIZE_BIT & Info.mVarTotalSize);
>+ CNObj.SetFlagsForBitField (0, LFlags);
>+ } else {
>+ //
>+ // Numeric doesn't support BOOLEAN data type.
>+ // BOOLEAN type has the same data size to UINT8.
>+ //
>+ if (Info.mVarType == EFI_IFR_TYPE_BOOLEAN) {
>+ Info.mVarType = EFI_IFR_TYPE_NUM_SIZE_8;
>+ }
>+ CNObj.SetFlags (0, Info.mVarType);
>+ //
>+ // Use maximum value not to limit the vaild value for the undefined
>question.
>+ //
>+ switch (Info.mVarType) {
>+ case EFI_IFR_TYPE_NUM_SIZE_64:
>+ CNObj.SetMinMaxStepData ((UINT64) 0, (UINT64) -1 , (UINT64) 0);
>+ ShrinkSize = 0;
>+ break;
>+ case EFI_IFR_TYPE_NUM_SIZE_32:
>+ CNObj.SetMinMaxStepData ((UINT32) 0, (UINT32) -1 , (UINT32) 0);
>+ ShrinkSize = 12;
>+ break;
>+ case EFI_IFR_TYPE_NUM_SIZE_16:
>+ CNObj.SetMinMaxStepData ((UINT16) 0, (UINT16) -1 , (UINT16) 0);
>+ ShrinkSize = 18;
>+ break;
>+ case EFI_IFR_TYPE_NUM_SIZE_8:
>+ CNObj.SetMinMaxStepData ((UINT8) 0, (UINT8) -1 , (UINT8) 0);
>+ ShrinkSize = 21;
>+ break;
>+ default:
>+ break;
>+ }
> }
> CNObj.ShrinkBinSize (ShrinkSize);
>
> //
> // For undefined Efi VarStore type question
>@@ -954,12 +975,22 @@ CFormPkg::DeclarePendingQuestion (
> }
>
> //
> // End for Numeric
> //
>- CIfrEnd CEObj;
>+ CIfrEnd CEObj;
> CEObj.SetLineNo (LineNo);
>+ //
>+ // End for Guided opcode
>+ //
>+ if (GuidObj != NULL) {
>+ CIfrEnd CEObjGuid;
>+ CEObjGuid.SetLineNo (LineNo);
>+ GuidObj->SetScope(1);
>+ delete GuidObj;
>+ GuidObj = NULL;
>+ }
> }
> }
>
> //
> // End for DisableIf
>diff --git a/BaseTools/Source/C/VfrCompile/VfrFormPkg.h
>b/BaseTools/Source/C/VfrCompile/VfrFormPkg.h
>index 17ab14c..8a22cb2 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:
>@@ -607,12 +615,16 @@ public:
> break;
> }
> return MaxValue;
> }
>
>- UINT64 GetStepData (UINT8 VarType) {
>+ UINT64 GetStepData (UINT8 VarType, BOOLEAN IsBitVar) {
> UINT64 MaxValue = 0;
>+ if (IsBitVar) {
>+ MaxValue = mMinMaxStepData->u32.Step;
>+ return MaxValue;
>+ }
> switch (VarType) {
> case EFI_IFR_TYPE_NUM_SIZE_64:
> MaxValue = mMinMaxStepData->u64.Step;
> break;
> case EFI_IFR_TYPE_NUM_SIZE_32:
>@@ -1405,10 +1417,26 @@ public:
> mNumeric->Flags = LFlags;
> }
> return VFR_RETURN_SUCCESS;
> }
>
>+ EFI_VFR_RETURN_CODE SetFlagsForBitField (IN UINT8 HFlags, IN UINT8
>LFlags, BOOLEAN DisplaySettingsSpecified = FALSE) {
>+ EFI_VFR_RETURN_CODE Ret;
>+
>+ Ret = CIfrQuestionHeader::SetFlags (HFlags);
>+ if (Ret != VFR_RETURN_SUCCESS) {
>+ return Ret;
>+ }
>+
>+ if (DisplaySettingsSpecified == FALSE) {
>+ mNumeric->Flags = LFlags | EDKII_IFR_DISPLAY_UINT_DEC_BIT;
>+ } else {
>+ mNumeric->Flags = LFlags;
>+ }
>+ return VFR_RETURN_SUCCESS;
>+ }
>+
> UINT8 GetNumericFlags () {
> return mNumeric->Flags;
> }
> };
>
>@@ -1445,10 +1473,26 @@ public:
> mOneOf->Flags = LFlags | EFI_IFR_DISPLAY_UINT_DEC;
> }
> return VFR_RETURN_SUCCESS;
> }
>
>+ EFI_VFR_RETURN_CODE SetFlagsForBitField (IN UINT8 HFlags, IN UINT8
>LFlags) {
>+ EFI_VFR_RETURN_CODE Ret;
>+
>+ Ret = CIfrQuestionHeader::SetFlags (HFlags);
>+ if (Ret != VFR_RETURN_SUCCESS) {
>+ return Ret;
>+ }
>+
>+ if (LFlags & EFI_IFR_DISPLAY) {
>+ mOneOf->Flags = LFlags;
>+ } else {
>+ mOneOf->Flags = LFlags | EDKII_IFR_DISPLAY_UINT_DEC_BIT;
>+ }
>+ return VFR_RETURN_SUCCESS;
>+ }
>+
> VOID ShrinkBinSize (IN UINT16 Size) {
> //
> // Update the buffer size which is truly be used later.
> //
> ShrinkObjBin(Size);
>diff --git a/BaseTools/Source/C/VfrCompile/VfrSyntax.g
>b/BaseTools/Source/C/VfrCompile/VfrSyntax.g
>index 24e0538..fbd5abf 100644
>--- a/BaseTools/Source/C/VfrCompile/VfrSyntax.g
>+++ b/BaseTools/Source/C/VfrCompile/VfrSyntax.g
>@@ -361,11 +361,15 @@ vfrDataStructFields [BOOLEAN FieldInUnion]:
> dataStructFieldBool [FieldInUnion] |
> dataStructFieldString [FieldInUnion]|
> dataStructFieldDate [FieldInUnion] |
> dataStructFieldTime [FieldInUnion] |
> dataStructFieldRef [FieldInUnion] |
>- dataStructFieldUser [FieldInUnion]
>+ dataStructFieldUser [FieldInUnion] |
>+ dataStructBitField64 [FieldInUnion] |
>+ dataStructBitField32 [FieldInUnion] |
>+ dataStructBitField16 [FieldInUnion] |
>+ dataStructBitField8 [FieldInUnion]
> )*
> ;
>
> dataStructField64 [BOOLEAN FieldInUnion]:
> << UINT32 ArrayNum = 0; >>
>@@ -467,10 +471,87 @@ dataStructFieldUser [BOOLEAN FieldInUnion]:
> OpenBracket I:Number CloseBracket << ArrayNum = _STOU32(I-
>>getText(), I->getLine()); >>
> }
> ";" <<
>_PCATCH(gCVfrVarDataTypeDB.DataTypeAddField (N->getText(), T-
>>getText(), ArrayNum, FieldInUnion), T); >>
> ;
>
>+dataStructBitField64[BOOLEAN FieldInUnion]:
>+ <<
>+ UINT32 Width = 0;
>+ BOOLEAN HasBitFieldName = FALSE;
>+ >>
>+ D:"UINT64"
>+ {
>+ N:StringIdentifier << HasBitFieldName = TRUE;>>
>+ }
>+ ":" I:Number << Width = _STOU32(I->getText(), I->getLine());>>
>+
>+ ";" << if (HasBitFieldName) {
>+ _PCATCH(gCVfrVarDataTypeDB.DataTypeAddBitField (N-
>>getText(), D->getText(), Width, FieldInUnion), N);
>+ } else {
>+ _PCATCH(gCVfrVarDataTypeDB.DataTypeAddBitField (NULL,
>D->getText(), Width, FieldInUnion), D);
>+ }
>+ >>
>+ ;
>+
>+dataStructBitField32[BOOLEAN FieldInUnion]:
>+ <<
>+ UINT32 Width = 0;
>+ BOOLEAN HasBitFieldName = FALSE;
>+ >>
>+ D:"UINT32"
>+ {
>+ N:StringIdentifier << HasBitFieldName = TRUE;>>
>+ }
>+
>+ ":" I:Number << Width = _STOU32(I->getText(), I->getLine());>>
>+
>+ ";" << if (HasBitFieldName) {
>+ _PCATCH(gCVfrVarDataTypeDB.DataTypeAddBitField (N-
>>getText(), D->getText(), Width, FieldInUnion), N);
>+ } else {
>+ _PCATCH(gCVfrVarDataTypeDB.DataTypeAddBitField (NULL,
>D->getText(), Width, FieldInUnion), D);
>+ }
>+ >>
>+ ;
>+
>+dataStructBitField16[BOOLEAN FieldInUnion]:
>+ <<
>+ UINT32 Width = 0;
>+ BOOLEAN HasBitFieldName = FALSE;
>+ >>
>+ D:"UINT16"
>+ {
>+ N:StringIdentifier << HasBitFieldName = TRUE;>>
>+ }
>+ ":" I:Number << Width = _STOU32(I->getText(), I->getLine());>>
>+
>+ ";" << if (HasBitFieldName) {
>+ _PCATCH(gCVfrVarDataTypeDB.DataTypeAddBitField (N-
>>getText(), D->getText(), Width, FieldInUnion), N);
>+ } else {
>+ _PCATCH(gCVfrVarDataTypeDB.DataTypeAddBitField (NULL,
>D->getText(), Width, FieldInUnion), D);
>+ }
>+ >>
>+ ;
>+
>+dataStructBitField8[BOOLEAN FieldInUnion]:
>+ <<
>+ UINT32 Width = 0;
>+ BOOLEAN HasBitFieldName = FALSE;
>+ >>
>+ D:"UINT8"
>+ {
>+ N:StringIdentifier << HasBitFieldName = TRUE;>>
>+ }
>+ ":" I:Number << Width = _STOU32(I->getText(), I->getLine());>>
>+
>+ ";" << if (HasBitFieldName) {
>+ _PCATCH(gCVfrVarDataTypeDB.DataTypeAddBitField (N-
>>getText(), D->getText(), Width, FieldInUnion), N);
>+ } else {
>+ _PCATCH(gCVfrVarDataTypeDB.DataTypeAddBitField (NULL,
>D->getText(), Width, FieldInUnion), D);
>+ }
>+ >>
>+ ;
>+
>
>//**********************************************************
>*******************
> //
> // the syntax of GUID definition
> //
> guidSubDefinition [EFI_GUID &Guid] :
>@@ -749,10 +830,15 @@ vfrExtensionData[UINT8 *DataBuff, UINT32 Size,
>CHAR8 *TypeName, UINT32 TypeSize,
> UINT8 Data_U8 = 0;
> BOOLEAN Data_BL = 0;
> EFI_STRING_ID Data_SID = 0;
> BOOLEAN IsArray = FALSE;
> UINT8 *ByteOffset = NULL;
>+ BOOLEAN BitField = FALSE;
>+ UINT64 Value;
>+ UINT64 Mask;
>+ UINT16 Offset;
>+ UINT8 PreBits;
> >>
> (
> ("," "data" {OpenBracket IDX1:Number CloseBracket <<IsArray = TRUE;>>}
> <<
> ArrayIdx = 0;
>@@ -805,27 +891,73 @@ vfrExtensionData[UINT8 *DataBuff, UINT32 Size,
>CHAR8 *TypeName, UINT32 TypeSize,
> }else if (strcmp ("EFI_STRING_ID", TypeName) == 0) {
> Data_SID = _STOSID(RD->getText(), RD->getLine());
> memcpy (ByteOffset, &Data_SID, TypeSize);
> }
> } else {
>- gCVfrVarDataTypeDB.GetDataFieldInfo(TFName, FieldOffset,
>FieldType, FieldSize);
>+ gCVfrVarDataTypeDB.GetDataFieldInfo(TFName, FieldOffset,
>FieldType, FieldSize, BitField);
>+ if (BitField) {
>+ Mask = (1 << FieldSize) - 1;
>+ Offset = FieldOffset / 8;
>+ PreBits = FieldOffset % 8;
>+ Mask <<= PreBits;
>+ }
> switch (FieldType) {
> case EFI_IFR_TYPE_NUM_SIZE_8:
> Data_U8 = _STOU8(RD->getText(), RD->getLine());
>- memcpy (ByteOffset + FieldOffset, &Data_U8, FieldSize);
>+ if (BitField) {
>+ //
>+ // Set the value to the bit fileds.
>+ //
>+ Value = *(UINT8*) (ByteOffset + Offset);
>+ Data_U8 <<= PreBits;
>+ Value = (Value & (~Mask)) | Data_U8;
>+ memcpy (ByteOffset + Offset, &Value, sizeof (UINT8));
>+ } else {
>+ memcpy (ByteOffset + FieldOffset, &Data_U8, FieldSize);
>+ }
> break;
> case EFI_IFR_TYPE_NUM_SIZE_16:
> Data_U16 = _STOU16(RD->getText(), RD->getLine());
>- memcpy (ByteOffset + FieldOffset, &Data_U16, FieldSize);
>+ if (BitField) {
>+ //
>+ // Set the value to the bit fileds.
>+ //
>+ Value = *(UINT16*) (ByteOffset + Offset);
>+ Data_U16 <<= PreBits;
>+ Value = (Value & (~Mask)) | Data_U16;
>+ memcpy (ByteOffset + Offset, &Value, sizeof (UINT16));
>+ } else {
>+ memcpy (ByteOffset + FieldOffset, &Data_U16, FieldSize);
>+ }
> break;
> case EFI_IFR_TYPE_NUM_SIZE_32:
> Data_U32 = _STOU32(RD->getText(), RD->getLine());
>- memcpy (ByteOffset + FieldOffset, &Data_U32, FieldSize);
>+ if (BitField) {
>+ //
>+ // Set the value to the bit fileds.
>+ //
>+ Value = *(UINT32*) (ByteOffset + Offset);
>+ Data_U32 <<= PreBits;
>+ Value = (Value & (~Mask)) | Data_U32;
>+ memcpy (ByteOffset + Offset, &Value, sizeof (UINT32));
>+ } else {
>+ memcpy (ByteOffset + FieldOffset, &Data_U32, FieldSize);
>+ }
> break;
> case EFI_IFR_TYPE_NUM_SIZE_64:
> Data_U64 = _STOU64(RD->getText(), RD->getLine());
>- memcpy (ByteOffset + FieldOffset, &Data_U64, FieldSize);
>+ if (BitField) {
>+ //
>+ // Set the value to the bit fileds.
>+ //
>+ Value = *(UINT64*) (ByteOffset + Offset);
>+ Data_U64 <<= PreBits;
>+ Value = (Value & (~Mask)) | Data_U64;
>+ memcpy (ByteOffset + Offset, &Value, sizeof (UINT64));
>+ } else {
>+ memcpy (ByteOffset + FieldOffset, &Data_U64, FieldSize);
>+ }
> break;
> case EFI_IFR_TYPE_BOOLEAN:
> Data_BL = _STOU8(RD->getText(), RD->getLine());
> memcpy (ByteOffset + FieldOffset, &Data_BL, FieldSize);
> break;
>@@ -872,14 +1004,15 @@ vfrStatementVarStoreLinear :
> CHAR8 *TypeName;
> CHAR8 *StoreName;
> UINT32 LineNum;
> EFI_VARSTORE_ID VarStoreId = EFI_VARSTORE_ID_INVALID;
> UINT32 Size;
>+ BOOLEAN IsBitVarStore = FALSE;
> >>
> V:Varstore << VSObj.SetLineNo(V->getLine()); >>
> (
>- TN:StringIdentifier "," << TypeName = TN->getText(); LineNum
>= TN->getLine(); >>
>+ TN:StringIdentifier "," << TypeName = TN->getText(); LineNum
>= TN->getLine(); IsBitVarStore = gCVfrVarDataTypeDB.DataTypeHasBitField
>(TN->getText());>>
> | U8:"UINT8" "," << TypeName = U8->getText(); LineNum =
>U8->getLine(); >>
> | U16:"UINT16" "," << TypeName = U16->getText(); LineNum
>= U16->getLine(); >>
> | C16:"CHAR16" "," << TypeName = (CHAR8 *) "UINT16";
>LineNum = C16->getLine(); >>
> | U32:"UINT32" "," << TypeName = U32->getText(); LineNum
>= U32->getLine(); >>
> | U64:"UINT64" "," << TypeName = U64->getText(); LineNum
>= U64->getLine(); >>
>@@ -910,16 +1043,17 @@ vfrStatementVarStoreLinear :
> StoreName = TypeName;
> } else {
> StoreName = SN->getText();
> }
>
>_PCATCH(gCVfrDataStorage.DeclareBufferVarStore (
>- StoreName,
>- &Guid,
>- &gCVfrVarDataTypeDB,
>- TypeName,
>- VarStoreId
>- ), LineNum);
>+ StoreName,
>+ &Guid,
>+ &gCVfrVarDataTypeDB,
>+ TypeName,
>+ VarStoreId,
>+ IsBitVarStore
>+ ), LineNum);
> VSObj.SetGuid (&Guid);
>
>_PCATCH(gCVfrDataStorage.GetVarStoreId(StoreName, &VarStoreId, &Guid),
>SN);
> VSObj.SetVarStoreId (VarStoreId);
>
>_PCATCH(gCVfrVarDataTypeDB.GetDataTypeSize(TypeName, &Size),
>LineNum);
> VSObj.SetSize ((UINT16) Size);
>@@ -938,14 +1072,15 @@ 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; >>
>+ TN:StringIdentifier "," << TypeName = TN->getText(); LineNum
>= TN->getLine(); CustomizedName = TRUE; IsBitVarStore =
>gCVfrVarDataTypeDB.DataTypeHasBitField (TN->getText());>>
> | U8:"UINT8" "," << TypeName = U8->getText(); LineNum =
>U8->getLine(); >>
> | U16:"UINT16" "," << TypeName = U16->getText(); LineNum
>= U16->getLine(); >>
> | C16:"CHAR16" "," << TypeName = (CHAR8 *) "UINT16";
>LineNum = C16->getLine(); >>
> | U32:"UINT32" "," << TypeName = U32->getText(); LineNum
>= U32->getLine(); >>
> | U64:"UINT64" "," << TypeName = U64->getText(); LineNum
>= U64->getLine(); >>
>@@ -1002,30 +1137,32 @@ vfrStatementVarStoreEfi :
> )
>
> Uuid "=" guidDefinition[Guid] <<
> if (IsUEFI23EfiVarstore) {
>
>_PCATCH(gCVfrDataStorage.DeclareBufferVarStore (
>- StoreName,
>- &Guid,
>- &gCVfrVarDataTypeDB,
>- TypeName,
>- VarStoreId
>- ), LineNum);
>+ StoreName,
>+ &Guid,
>+ &gCVfrVarDataTypeDB,
>+ TypeName,
>+ VarStoreId,
>+ IsBitVarStore
>+ ), LineNum);
>
>_PCATCH(gCVfrDataStorage.GetVarStoreId(StoreName, &VarStoreId, &Guid),
>SN);
>
>_PCATCH(gCVfrVarDataTypeDB.GetDataTypeSize(TypeName, &Size),
>LineNum);
> } else {
>-
>_PCATCH(gCVfrDataStorage.DeclareBufferVarStore (
>+
>_PCATCH(gCVfrDataStorage.DeclareBufferVarStore (
> TN->getText(),
> &Guid,
> &gCVfrVarDataTypeDB,
> TypeName,
>- VarStoreId
>- ), LineNum);
>+ VarStoreId,
>+ FALSE
>+ ), LineNum);
> _PCATCH(gCVfrDataStorage.GetVarStoreId(TN-
>>getText(), &VarStoreId, &Guid), VN);
>
>_PCATCH(gCVfrVarDataTypeDB.GetDataTypeSize(TypeName, &Size), N-
>>getLine());
> }
>- VSEObj.SetGuid (&Guid);
>+ VSEObj.SetGuid (&Guid);
> VSEObj.SetVarStoreId (VarStoreId);
>
> VSEObj.SetSize ((UINT16) Size);
> VSEObj.SetName (StoreName);
> if (IsUEFI23EfiVarstore == FALSE && StoreName !=
>NULL) {
>@@ -1139,71 +1276,79 @@ vfrStatementSuppressIfFormSet :
> vfrStatementHeader[CIfrStatementHeader *SHObj] :
> Prompt "=" "STRING_TOKEN" "\(" S1:Number "\)" "," << $SHObj-
>>SetPrompt (_STOSID(S1->getText(), S1->getLine())); >>
> Help "=" "STRING_TOKEN" "\(" S2:Number "\)" << $SHObj->SetHelp
>(_STOSID(S2->getText(), S2->getLine())); >>
> ;
>
>+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);
>+ >>
>+ ;
>+
> vfrQuestionHeader[CIfrQuestionHeader & QHObj, EFI_QUESION_TYPE
>QType = QUESTION_NORMAL]:
> <<
> 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;
> >>
>- {
>- 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);
>- }
>- $QHObj.SetQuestionId (QId);
>- if (VarIdStr != NULL) {
>- $QHObj.SetVarStoreInfo (&Info);
>- }
>+ vfrQuestionBaseInfo[Info, QId, QType]
>+ << $QHObj.SetQuestionId (QId);
>+ if (Info.mVarStoreId !=
>EFI_VARSTORE_ID_INVALID) {
>+ $QHObj.SetVarStoreInfo (&Info);
>+ }
> >>
> vfrStatementHeader[&$QHObj]
>- <<
>- if (VarIdStr != NULL) {
>- delete VarIdStr;
>- }
>- _SAVE_CURRQEST_VARINFO (Info);
>- >>
> ;
>
> questionheaderFlagsField[UINT8 & Flags] :
> ReadOnlyFlag << $Flags |= 0x01; >>
> | InteractiveFlag << $Flags |= 0x04; >>
>@@ -1268,10 +1413,11 @@ vfrStorageVarId[EFI_VARSTORE_INFO & Info,
>CHAR8 *&QuestVarIdStr, BOOLEAN CheckFl
> SName,
> &mFormsetGuid,
> &gCVfrVarDataTypeDB,
> SName,
> EFI_VARSTORE_ID_INVALID,
>+ FALSE,
> FALSE
> );
> VfrReturnCode =
>gCVfrDataStorage.GetVarStoreId(SName, &$Info.mVarStoreId,
>&mFormsetGuid);
> }
> if (CheckFlag || VfrReturnCode ==
>VFR_RETURN_SUCCESS) {
>@@ -1299,21 +1445,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.mVarSto
>reId, &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()); >>
> {
>@@ -1338,11 +1484,12 @@ 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);
>+ case EFI_VFR_VARSTORE_BUFFER_BITS:
>+
>_PCATCH(gCVfrVarDataTypeDB.GetDataFieldInfo (VarStr,
>$Info.mInfo.mVarOffset, $Info.mVarType, $Info.mVarTotalSize,
>$Info.mIsBitVar), SN2->getLine(), VarStr);
> VarGuid =
>gCVfrDataStorage.GetVarStoreGuid($Info.mVarStoreId);
>
>_PCATCH((EFI_VFR_RETURN_CODE)gCVfrBufferConfig.Register (
> SName,
> VarGuid,
> NULL),
>@@ -1436,90 +1583,97 @@ vfrConstantValueField[UINT8 Type,
>EFI_IFR_TYPE_VALUE &Value, BOOLEAN &ListType]
> >>
> {
> "\-" << Negative = TRUE; >>
> }
> N1:Number <<
>- switch ($Type) {
>- case EFI_IFR_TYPE_NUM_SIZE_8 :
>- $Value.u8 = _STOU8(N1->getText(), N1-
>>getLine());
>- if (IntDecStyle) {
>- if (Negative) {
>- if ($Value.u8 > 0x80) {
>- _PCATCH
>(VFR_RETURN_INVALID_PARAMETER, N1->getLine(), "INT8 type can't big
>than 0x7F, small than -0x80");
>- }
>- } else {
>- if ($Value.u8 > 0x7F) {
>- _PCATCH
>(VFR_RETURN_INVALID_PARAMETER, N1->getLine(), "INT8 type can't big
>than 0x7F, small than -0x80");
>+ //
>+ // The value stored in bit fields is always set to
>UINT32 type.
>+ //
>+ 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) {
>+ if ($Value.u8 > 0x80) {
>+ _PCATCH
>(VFR_RETURN_INVALID_PARAMETER, N1->getLine(), "INT8 type can't big
>than 0x7F, small than -0x80");
>+ }
>+ } else {
>+ if ($Value.u8 > 0x7F) {
>+ _PCATCH
>(VFR_RETURN_INVALID_PARAMETER, N1->getLine(), "INT8 type can't big
>than 0x7F, small than -0x80");
>+ }
> }
> }
>- }
>- if (Negative) {
>- $Value.u8 = ~$Value.u8 + 1;
>- }
>- break;
>- case EFI_IFR_TYPE_NUM_SIZE_16 :
>- $Value.u16 = _STOU16(N1->getText(), N1-
>>getLine());
>- if (IntDecStyle) {
> if (Negative) {
>- if ($Value.u16 > 0x8000) {
>- _PCATCH
>(VFR_RETURN_INVALID_PARAMETER, N1->getLine(), "INT16 type can't big
>than 0x7FFF, small than -0x8000");
>- }
>- } else {
>- if ($Value.u16 > 0x7FFF) {
>- _PCATCH
>(VFR_RETURN_INVALID_PARAMETER, N1->getLine(), "INT16 type can't big
>than 0x7FFF, small than -0x8000");
>+ $Value.u8 = ~$Value.u8 + 1;
>+ }
>+ break;
>+ case EFI_IFR_TYPE_NUM_SIZE_16 :
>+ $Value.u16 = _STOU16(N1->getText(), N1-
>>getLine());
>+ if (IntDecStyle) {
>+ if (Negative) {
>+ if ($Value.u16 > 0x8000) {
>+ _PCATCH
>(VFR_RETURN_INVALID_PARAMETER, N1->getLine(), "INT16 type can't big
>than 0x7FFF, small than -0x8000");
>+ }
>+ } else {
>+ if ($Value.u16 > 0x7FFF) {
>+ _PCATCH
>(VFR_RETURN_INVALID_PARAMETER, N1->getLine(), "INT16 type can't big
>than 0x7FFF, small than -0x8000");
>+ }
> }
> }
>- }
>- if (Negative) {
>- $Value.u16 = ~$Value.u16 + 1;
>- }
>- break;
>- case EFI_IFR_TYPE_NUM_SIZE_32 :
>- $Value.u32 = _STOU32(N1->getText(), N1-
>>getLine());
>- if (IntDecStyle) {
> if (Negative) {
>- if ($Value.u32 > 0x80000000) {
>- _PCATCH
>(VFR_RETURN_INVALID_PARAMETER, N1->getLine(), "INT32 type can't big
>than 0x7FFFFFFF, small than -0x80000000");
>- }
>- } else {
>- if ($Value.u32 > 0X7FFFFFFF) {
>- _PCATCH
>(VFR_RETURN_INVALID_PARAMETER, N1->getLine(), "INT32 type can't big
>than 0x7FFFFFFF, small than -0x80000000");
>+ $Value.u16 = ~$Value.u16 + 1;
>+ }
>+ break;
>+ case EFI_IFR_TYPE_NUM_SIZE_32 :
>+ $Value.u32 = _STOU32(N1->getText(), N1-
>>getLine());
>+ if (IntDecStyle) {
>+ if (Negative) {
>+ if ($Value.u32 > 0x80000000) {
>+ _PCATCH
>(VFR_RETURN_INVALID_PARAMETER, N1->getLine(), "INT32 type can't big
>than 0x7FFFFFFF, small than -0x80000000");
>+ }
>+ } else {
>+ if ($Value.u32 > 0X7FFFFFFF) {
>+ _PCATCH
>(VFR_RETURN_INVALID_PARAMETER, N1->getLine(), "INT32 type can't big
>than 0x7FFFFFFF, small than -0x80000000");
>+ }
> }
> }
>- }
>- if (Negative) {
>- $Value.u32 = ~$Value.u32 + 1;
>- }
>- break;
>- case EFI_IFR_TYPE_NUM_SIZE_64 :
>- $Value.u64 = _STOU64(N1->getText(), N1-
>>getLine());
>- if (IntDecStyle) {
> if (Negative) {
>- if ($Value.u64 > 0x8000000000000000) {
>- _PCATCH
>(VFR_RETURN_INVALID_PARAMETER, N1->getLine(), "INT64 type can't big
>than 0x7FFFFFFFFFFFFFFF, small than -0x8000000000000000");
>- }
>- } else {
>- if ($Value.u64 > 0x7FFFFFFFFFFFFFFF) {
>- _PCATCH
>(VFR_RETURN_INVALID_PARAMETER, N1->getLine(), "INT64 type can't big
>than 0x7FFFFFFFFFFFFFFF, small than -0x8000000000000000");
>+ $Value.u32 = ~$Value.u32 + 1;
>+ }
>+ break;
>+ case EFI_IFR_TYPE_NUM_SIZE_64 :
>+ $Value.u64 = _STOU64(N1->getText(), N1-
>>getLine());
>+ if (IntDecStyle) {
>+ if (Negative) {
>+ if ($Value.u64 > 0x8000000000000000) {
>+ _PCATCH
>(VFR_RETURN_INVALID_PARAMETER, N1->getLine(), "INT64 type can't big
>than 0x7FFFFFFFFFFFFFFF, small than -0x8000000000000000");
>+ }
>+ } else {
>+ if ($Value.u64 > 0x7FFFFFFFFFFFFFFF) {
>+ _PCATCH
>(VFR_RETURN_INVALID_PARAMETER, N1->getLine(), "INT64 type can't big
>than 0x7FFFFFFFFFFFFFFF, small than -0x8000000000000000");
>+ }
> }
> }
>+ if (Negative) {
>+ $Value.u64 = ~$Value.u64 + 1;
>+ }
>+ break;
>+ case EFI_IFR_TYPE_BOOLEAN :
>+ $Value.b = _STOU8(N1->getText(), N1-
>>getLine());
>+ break;
>+ case EFI_IFR_TYPE_STRING :
>+ $Value.string = _STOU16(N1->getText(), N1-
>>getLine());
>+ break;
>+ case EFI_IFR_TYPE_TIME :
>+ case EFI_IFR_TYPE_DATE :
>+ case EFI_IFR_TYPE_REF :
>+ default :
>+ break;
> }
>- if (Negative) {
>- $Value.u64 = ~$Value.u64 + 1;
>- }
>- break;
>- case EFI_IFR_TYPE_BOOLEAN :
>- $Value.b = _STOU8(N1->getText(), N1-
>>getLine());
>- break;
>- case EFI_IFR_TYPE_STRING :
>- $Value.string = _STOU16(N1->getText(), N1-
>>getLine());
>- break;
>- case EFI_IFR_TYPE_TIME :
>- 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()); >>
>@@ -1689,42 +1843,51 @@ 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())) {
>+ //
>+ // Value for question stored in bit fields is
>always set to UINT32 type.
>+ //
>+ 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.");
>@@ -1759,21 +1922,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()); >>
>@@ -2176,39 +2347,72 @@ 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] <<
>+ //
>+ // Create a GUID opcode to wrap the checkbox
>opcode, if it refer to bit varstore.
>+ //
>+ if (_GET_CURRQEST_VARTINFO().mIsBitVar) {
>+ GuidObj = new CIfrGuid(0);
>+ GuidObj->SetGuid (&gEdkiiIfrBitVarGuid);
>+ 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) {
>+ _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().mVarStor
>eId);
> 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(),
>@@ -2220,11 +2424,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(),
>@@ -2240,14 +2444,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] :
> <<
>@@ -2439,11 +2650,12 @@ vfrSetMinMaxStep[CIfrMinMaxStepData &
>MMSDObj] :
> UINT32 MaxU4 = 0, MinU4 = 0, StepU4 = 0;
> UINT16 MaxU2 = 0, MinU2 = 0, StepU2 = 0;
> UINT8 MaxU1 = 0, MinU1 = 0, StepU1 = 0;
> BOOLEAN IntDecStyle = FALSE;
> CIfrNumeric *NObj = (CIfrNumeric *) (&MMSDObj);
>- if ((NObj->GetOpCode() == EFI_IFR_NUMERIC_OP) && ((NObj-
>>GetNumericFlags() & EFI_IFR_DISPLAY) == 0)) {
>+ if (((_GET_CURRQEST_VARTINFO().mIsBitVar) && (NObj->GetOpCode()
>== EFI_IFR_NUMERIC_OP) && ((NObj->GetNumericFlags() &
>EDKII_IFR_DISPLAY_BIT) == 0)) ||
>+ (!(_GET_CURRQEST_VARTINFO().mIsBitVar) && (NObj->GetOpCode() ==
>EFI_IFR_NUMERIC_OP) && ((NObj->GetNumericFlags() & EFI_IFR_DISPLAY)
>== 0))) {
> IntDecStyle = TRUE;
> }
> BOOLEAN MinNegative = FALSE;
> BOOLEAN MaxNegative = FALSE;
> >>
>@@ -2453,383 +2665,539 @@ 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. ");
> }
>- switch (_GET_CURRQEST_DATATYPE()) {
>- case EFI_IFR_TYPE_NUM_SIZE_64 :
>- MinU8 = _STOU64(I->getText(), I->getLine());
>- if (IntDecStyle) {
>- if (MinNegative) {
>- if (MinU8 > 0x8000000000000000) {
>- _PCATCH
>(VFR_RETURN_INVALID_PARAMETER, I->getLine(), "INT64 type minimum
>can't small than -0x8000000000000000, big than 0x7FFFFFFFFFFFFFFF");
>- }
>- } else {
>- if (MinU8 > 0x7FFFFFFFFFFFFFFF) {
>- _PCATCH
>(VFR_RETURN_INVALID_PARAMETER, I->getLine(), "INT64 type minimum
>can't small than -0x8000000000000000, big than 0x7FFFFFFFFFFFFFFF");
>- }
>- }
>- }
>- if (MinNegative) {
>- MinU8 = ~MinU8 + 1;
>- }
>- break;
>- case EFI_IFR_TYPE_NUM_SIZE_32 :
>+ //
>+ // Value for question stored in bit fields is
>always set to UINT32 type.
>+ //
>+ if (_GET_CURRQEST_VARTINFO().mIsBitVar) {
> MinU4 = _STOU32(I->getText(), I->getLine());
>- if (IntDecStyle) {
>- if (MinNegative) {
>- if (MinU4 > 0x80000000) {
>- _PCATCH
>(VFR_RETURN_INVALID_PARAMETER, I->getLine(), "INT32 type minimum
>can't small than -0x80000000, big than 0x7FFFFFFF");
>- }
>- } else {
>- if (MinU4 > 0x7FFFFFFF) {
>- _PCATCH
>(VFR_RETURN_INVALID_PARAMETER, I->getLine(), "INT32 type minimum
>can't small than -0x80000000, big than 0x7FFFFFFF");
>- }
>- }
>- }
>- if (MinNegative) {
>- MinU4 = ~MinU4 + 1;
>+ if (!IntDecStyle && MinU4 > (1<<
>_GET_CURRQEST_VARTINFO().mVarTotalSize) -1) {
>+ _PCATCH
>(VFR_RETURN_INVALID_PARAMETER, I->getLine(), "BIT type minimum can't
>small than 0, bigger than 2^BitWidth -1");
> }
>- break;
>- case EFI_IFR_TYPE_NUM_SIZE_16 :
>- MinU2 = _STOU16(I->getText(), I->getLine());
>- if (IntDecStyle) {
>- if (MinNegative) {
>- if (MinU2 > 0x8000) {
>- _PCATCH
>(VFR_RETURN_INVALID_PARAMETER, I->getLine(), "INT16 type minimum
>can't small than -0x8000, big than 0x7FFF");
>+ } else {
>+ switch (_GET_CURRQEST_DATATYPE()) {
>+ case EFI_IFR_TYPE_NUM_SIZE_64 :
>+ MinU8 = _STOU64(I->getText(), I->getLine());
>+ if (IntDecStyle) {
>+ if (MinNegative) {
>+ if (MinU8 > 0x8000000000000000) {
>+ _PCATCH
>(VFR_RETURN_INVALID_PARAMETER, I->getLine(), "INT64 type minimum
>can't small than -0x8000000000000000, big than 0x7FFFFFFFFFFFFFFF");
>+ }
>+ } else {
>+ if (MinU8 > 0x7FFFFFFFFFFFFFFF) {
>+ _PCATCH
>(VFR_RETURN_INVALID_PARAMETER, I->getLine(), "INT64 type minimum
>can't small than -0x8000000000000000, big than 0x7FFFFFFFFFFFFFFF");
>+ }
> }
>- } else {
>- if (MinU2 > 0x7FFF) {
>- _PCATCH
>(VFR_RETURN_INVALID_PARAMETER, I->getLine(), "INT16 type minimum
>can't small than -0x8000, big than 0x7FFF");
>+ }
>+ if (MinNegative) {
>+ MinU8 = ~MinU8 + 1;
>+ }
>+ break;
>+ case EFI_IFR_TYPE_NUM_SIZE_32 :
>+ MinU4 = _STOU32(I->getText(), I->getLine());
>+ if (IntDecStyle) {
>+ if (MinNegative) {
>+ if (MinU4 > 0x80000000) {
>+ _PCATCH
>(VFR_RETURN_INVALID_PARAMETER, I->getLine(), "INT32 type minimum
>can't small than -0x80000000, big than 0x7FFFFFFF");
>+ }
>+ } else {
>+ if (MinU4 > 0x7FFFFFFF) {
>+ _PCATCH
>(VFR_RETURN_INVALID_PARAMETER, I->getLine(), "INT32 type minimum
>can't small than -0x80000000, big than 0x7FFFFFFF");
>+ }
> }
> }
>- }
>- if (MinNegative) {
>- MinU2 = ~MinU2 + 1;
>- }
>- break;
>- case EFI_IFR_TYPE_NUM_SIZE_8 :
>- MinU1 = _STOU8(I->getText(), I->getLine());
>- if (IntDecStyle) {
>- if (MinNegative) {
>- if (MinU1 > 0x80) {
>- _PCATCH
>(VFR_RETURN_INVALID_PARAMETER, I->getLine(), "INT8 type minimum can't
>small than -0x80, big than 0x7F");
>+ if (MinNegative) {
>+ MinU4 = ~MinU4 + 1;
>+ }
>+ break;
>+ case EFI_IFR_TYPE_NUM_SIZE_16 :
>+ MinU2 = _STOU16(I->getText(), I->getLine());
>+ if (IntDecStyle) {
>+ if (MinNegative) {
>+ if (MinU2 > 0x8000) {
>+ _PCATCH
>(VFR_RETURN_INVALID_PARAMETER, I->getLine(), "INT16 type minimum
>can't small than -0x8000, big than 0x7FFF");
>+ }
>+ } else {
>+ if (MinU2 > 0x7FFF) {
>+ _PCATCH
>(VFR_RETURN_INVALID_PARAMETER, I->getLine(), "INT16 type minimum
>can't small than -0x8000, big than 0x7FFF");
>+ }
> }
>- } else {
>- if (MinU1 > 0x7F) {
>- _PCATCH
>(VFR_RETURN_INVALID_PARAMETER, I->getLine(), "INT8 type minimum can't
>small than -0x80, big than 0x7F");
>+ }
>+ if (MinNegative) {
>+ MinU2 = ~MinU2 + 1;
>+ }
>+ break;
>+ case EFI_IFR_TYPE_NUM_SIZE_8 :
>+ MinU1 = _STOU8(I->getText(), I->getLine());
>+ if (IntDecStyle) {
>+ if (MinNegative) {
>+ if (MinU1 > 0x80) {
>+ _PCATCH
>(VFR_RETURN_INVALID_PARAMETER, I->getLine(), "INT8 type minimum can't
>small than -0x80, big than 0x7F");
>+ }
>+ } else {
>+ if (MinU1 > 0x7F) {
>+ _PCATCH
>(VFR_RETURN_INVALID_PARAMETER, I->getLine(), "INT8 type minimum can't
>small than -0x80, big than 0x7F");
>+ }
> }
> }
>+ if (MinNegative) {
>+ MinU1 = ~MinU1 + 1;
>+ }
>+ break;
> }
>- 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. ");
> }
>-
>- switch (_GET_CURRQEST_DATATYPE()) {
>- case EFI_IFR_TYPE_NUM_SIZE_64 :
>- MaxU8 = _STOU64(A->getText(), A->getLine());
>- if (IntDecStyle) {
>+ if (_GET_CURRQEST_VARTINFO().mIsBitVar) {
>+ MaxU4 = _STOU32(A->getText(), A->getLine());
>+ if (!IntDecStyle && MaxU4 > (1<<
>_GET_CURRQEST_VARTINFO().mVarTotalSize) -1) {
>+ _PCATCH
>(VFR_RETURN_INVALID_PARAMETER, A->getLine(), "BIT type maximum can't
>bigger than 2^BitWidth -1");
>+ }
>+ } else {
>+ switch (_GET_CURRQEST_DATATYPE()) {
>+ case EFI_IFR_TYPE_NUM_SIZE_64 :
>+ MaxU8 = _STOU64(A->getText(), A-
>>getLine());
>+ if (IntDecStyle) {
>+ if (MaxNegative) {
>+ if (MaxU8 > 0x8000000000000000) {
>+ _PCATCH
>(VFR_RETURN_INVALID_PARAMETER, A->getLine(), "INT64 type maximum
>can't small than -0x8000000000000000, big than 0x7FFFFFFFFFFFFFFF");
>+ }
>+ } else {
>+ if (MaxU8 > 0x7FFFFFFFFFFFFFFF) {
>+ _PCATCH
>(VFR_RETURN_INVALID_PARAMETER, A->getLine(), "INT64 type maximum
>can't small than -0x8000000000000000, big than 0x7FFFFFFFFFFFFFFF");
>+ }
>+ }
>+ }
> if (MaxNegative) {
>- if (MaxU8 > 0x8000000000000000) {
>- _PCATCH
>(VFR_RETURN_INVALID_PARAMETER, A->getLine(), "INT64 type maximum
>can't small than -0x8000000000000000, big than 0x7FFFFFFFFFFFFFFF");
>+ MaxU8 = ~MaxU8 + 1;
>+ }
>+ if (IntDecStyle) {
>+ if ((INT64) MaxU8 < (INT64) MinU8) {
>+ _PCATCH
>(VFR_RETURN_INVALID_PARAMETER, A->getLine(), "Maximum can't be less
>than Minimum");
> }
> } else {
>- if (MaxU8 > 0x7FFFFFFFFFFFFFFF) {
>- _PCATCH
>(VFR_RETURN_INVALID_PARAMETER, A->getLine(), "INT64 type maximum
>can't small than -0x8000000000000000, big than 0x7FFFFFFFFFFFFFFF");
>+ if (MaxU8 < MinU8) {
>+ _PCATCH
>(VFR_RETURN_INVALID_PARAMETER, A->getLine(), "Maximum can't be less
>than Minimum");
> }
> }
>- }
>- if (MaxNegative) {
>- MaxU8 = ~MaxU8 + 1;
>- }
>- if (IntDecStyle) {
>- if ((INT64) MaxU8 < (INT64) MinU8) {
>- _PCATCH
>(VFR_RETURN_INVALID_PARAMETER, A->getLine(), "Maximum can't be less
>than Minimum");
>- }
>- } else {
>- if (MaxU8 < MinU8) {
>- _PCATCH
>(VFR_RETURN_INVALID_PARAMETER, A->getLine(), "Maximum can't be less
>than Minimum");
>+ break;
>+ case EFI_IFR_TYPE_NUM_SIZE_32 :
>+ MaxU4 = _STOU32(A->getText(), A-
>>getLine());
>+ if (IntDecStyle) {
>+ if (MaxNegative) {
>+ if (MaxU4 > 0x80000000) {
>+ _PCATCH
>(VFR_RETURN_INVALID_PARAMETER, A->getLine(), "INT32 type maximum
>can't small than -0x80000000, big than 0x7FFFFFFF");
>+ }
>+ } else {
>+ if (MaxU4 > 0x7FFFFFFF) {
>+ _PCATCH
>(VFR_RETURN_INVALID_PARAMETER, A->getLine(), "INT32 type maximum
>can't small than -0x80000000, big than 0x7FFFFFFF");
>+ }
>+ }
> }
>- }
>- break;
>- case EFI_IFR_TYPE_NUM_SIZE_32 :
>- MaxU4 = _STOU32(A->getText(), A->getLine());
>- if (IntDecStyle) {
> if (MaxNegative) {
>- if (MaxU4 > 0x80000000) {
>- _PCATCH
>(VFR_RETURN_INVALID_PARAMETER, A->getLine(), "INT32 type maximum
>can't small than -0x80000000, big than 0x7FFFFFFF");
>+ MaxU4 = ~MaxU4 + 1;
>+ }
>+ if (IntDecStyle) {
>+ if ((INT32) MaxU4 < (INT32) MinU4) {
>+ _PCATCH
>(VFR_RETURN_INVALID_PARAMETER, A->getLine(), "Maximum can't be less
>than Minimum");
> }
> } else {
>- if (MaxU4 > 0x7FFFFFFF) {
>- _PCATCH
>(VFR_RETURN_INVALID_PARAMETER, A->getLine(), "INT32 type maximum
>can't small than -0x80000000, big than 0x7FFFFFFF");
>+ if (MaxU4 < MinU4) {
>+ _PCATCH
>(VFR_RETURN_INVALID_PARAMETER, A->getLine(), "Maximum can't be less
>than Minimum");
> }
> }
>- }
>- if (MaxNegative) {
>- MaxU4 = ~MaxU4 + 1;
>- }
>- if (IntDecStyle) {
>- if ((INT32) MaxU4 < (INT32) MinU4) {
>- _PCATCH
>(VFR_RETURN_INVALID_PARAMETER, A->getLine(), "Maximum can't be less
>than Minimum");
>- }
>- } else {
>- if (MaxU4 < MinU4) {
>- _PCATCH
>(VFR_RETURN_INVALID_PARAMETER, A->getLine(), "Maximum can't be less
>than Minimum");
>+ break;
>+ case EFI_IFR_TYPE_NUM_SIZE_16 :
>+ MaxU2 = _STOU16(A->getText(), A-
>>getLine());
>+ if (IntDecStyle) {
>+ if (MaxNegative) {
>+ if (MaxU2 > 0x8000) {
>+ _PCATCH
>(VFR_RETURN_INVALID_PARAMETER, A->getLine(), "INT16 type maximum
>can't small than -0x8000, big than 0x7FFF");
>+ }
>+ } else {
>+ if (MaxU2 > 0x7FFF) {
>+ _PCATCH
>(VFR_RETURN_INVALID_PARAMETER, A->getLine(), "INT16 type maximum
>can't small than -0x8000, big than 0x7FFF");
>+ }
>+ }
> }
>- }
>- break;
>- case EFI_IFR_TYPE_NUM_SIZE_16 :
>- MaxU2 = _STOU16(A->getText(), A->getLine());
>- if (IntDecStyle) {
> if (MaxNegative) {
>- if (MaxU2 > 0x8000) {
>- _PCATCH
>(VFR_RETURN_INVALID_PARAMETER, A->getLine(), "INT16 type maximum
>can't small than -0x8000, big than 0x7FFF");
>+ MaxU2 = ~MaxU2 + 1;
>+ }
>+ if (IntDecStyle) {
>+ if ((INT16) MaxU2 < (INT16) MinU2) {
>+ _PCATCH
>(VFR_RETURN_INVALID_PARAMETER, A->getLine(), "Maximum can't be less
>than Minimum");
> }
> } else {
>- if (MaxU2 > 0x7FFF) {
>- _PCATCH
>(VFR_RETURN_INVALID_PARAMETER, A->getLine(), "INT16 type maximum
>can't small than -0x8000, big than 0x7FFF");
>+ if (MaxU2 < MinU2) {
>+ _PCATCH
>(VFR_RETURN_INVALID_PARAMETER, A->getLine(), "Maximum can't be less
>than Minimum");
> }
> }
>- }
>- if (MaxNegative) {
>- MaxU2 = ~MaxU2 + 1;
>- }
>- if (IntDecStyle) {
>- if ((INT16) MaxU2 < (INT16) MinU2) {
>- _PCATCH
>(VFR_RETURN_INVALID_PARAMETER, A->getLine(), "Maximum can't be less
>than Minimum");
>- }
>- } else {
>- if (MaxU2 < MinU2) {
>- _PCATCH
>(VFR_RETURN_INVALID_PARAMETER, A->getLine(), "Maximum can't be less
>than Minimum");
>+ break;
>+ case EFI_IFR_TYPE_NUM_SIZE_8 :
>+ MaxU1 = _STOU8(A->getText(), A->getLine());
>+ if (IntDecStyle) {
>+ if (MaxNegative) {
>+ if (MaxU1 > 0x80) {
>+ _PCATCH
>(VFR_RETURN_INVALID_PARAMETER, A->getLine(), "INT8 type maximum
>can't small than -0x80, big than 0x7F");
>+ }
>+ } else {
>+ if (MaxU1 > 0x7F) {
>+ _PCATCH
>(VFR_RETURN_INVALID_PARAMETER, A->getLine(), "INT8 type maximum
>can't small than -0x80, big than 0x7F");
>+ }
>+ }
> }
>- }
>- break;
>- case EFI_IFR_TYPE_NUM_SIZE_8 :
>- MaxU1 = _STOU8(A->getText(), A->getLine());
>- if (IntDecStyle) {
> if (MaxNegative) {
>- if (MaxU1 > 0x80) {
>- _PCATCH
>(VFR_RETURN_INVALID_PARAMETER, A->getLine(), "INT8 type maximum
>can't small than -0x80, big than 0x7F");
>+ MaxU1 = ~MaxU1 + 1;
>+ }
>+ if (IntDecStyle) {
>+ if ((INT8) MaxU1 < (INT8) MinU1) {
>+ _PCATCH
>(VFR_RETURN_INVALID_PARAMETER, A->getLine(), "Maximum can't be less
>than Minimum");
> }
> } else {
>- if (MaxU1 > 0x7F) {
>- _PCATCH
>(VFR_RETURN_INVALID_PARAMETER, A->getLine(), "INT8 type maximum
>can't small than -0x80, big than 0x7F");
>+ if (MaxU1 < MinU1) {
>+ _PCATCH
>(VFR_RETURN_INVALID_PARAMETER, A->getLine(), "Maximum can't be less
>than Minimum");
> }
> }
>+ break;
> }
>- if (MaxNegative) {
>- MaxU1 = ~MaxU1 + 1;
>- }
>- if (IntDecStyle) {
>- if ((INT8) MaxU1 < (INT8) MinU1) {
>- _PCATCH
>(VFR_RETURN_INVALID_PARAMETER, A->getLine(), "Maximum can't be less
>than Minimum");
>- }
>- } else {
>- if (MaxU1 < MinU1) {
>- _PCATCH
>(VFR_RETURN_INVALID_PARAMETER, A->getLine(), "Maximum can't be less
>than Minimum");
>- }
>- }
>- break;
> }
> >>
> {
> STEP "=" S:Number ","
> <<
>- 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) {
>+ 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;
>+ }
> }
> >>
> }
> <<
>- 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;
>+ 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] <<
>+ //
>+ // Create a GUID opcode to wrap the numeric
>opcode, if it refer to bit varstore.
>+ //
>+ if (_GET_CURRQEST_VARTINFO().mIsBitVar) {
>+ GuidObj = new CIfrGuid(0);
>+ GuidObj->SetGuid (&gEdkiiIfrBitVarGuid);
>+ 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) {
>+ LFlags = (EDKII_IFR_NUMERIC_SIZE_BIT &
>(_GET_CURRQEST_VARSIZE()));
>+ _PCATCH(NObj->SetFlagsForBitField (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()) {
>+ vfrSetMinMaxStep[*NObj] <<
>+ if (!_GET_CURRQEST_VARTINFO().mIsBitVar) {
>+ 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 {
> //
>- // Base on the type to know the actual used
>size,shrink the buffer
>- // size allocate before.
>+ // Question stored in bit fields saved as UINT32
>type, so the ShrinkSize same as EFI_IFR_TYPE_NUM_SIZE_32.
> //
>- 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;
>+ ShrinkSize = 12;
> }
>- 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] :
> <<
> UINT8 LFlags = _GET_CURRQEST_DATATYPE() & EFI_IFR_NUMERIC_SIZE;
> UINT8 HFlags = 0;
>- EFI_VFR_VARSTORE_TYPE VarStoreType = EFI_VFR_VARSTORE_INVALID;
> BOOLEAN IsSetType = FALSE;
> BOOLEAN IsDisplaySpecified = FALSE;
>+ EFI_VFR_VARSTORE_TYPE VarStoreType =
>gCVfrDataStorage.GetVarStoreType
>(_GET_CURRQEST_VARTINFO().mVarStoreId);
> >>
>- numericFlagsField[HFlags, LFlags, IsSetType, IsDisplaySpecified] ( "\|"
>numericFlagsField[HFlags, LFlags, IsSetType, IsDisplaySpecified ] )*
>+ numericFlagsField[HFlags, LFlags, IsSetType, IsDisplaySpecified, LineNum]
>( "\|" numericFlagsField[HFlags, LFlags, IsSetType, IsDisplaySpecified,
>LineNum] )*
> <<
> //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) {
>+ if
>(_GET_CURRQEST_VARTINFO().mVarStoreId != EFI_VARSTORE_ID_INVALID)
>{
>+ 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;
>+ _PCATCH(NObj.SetFlags (HFlags, LFlags,
>IsDisplaySpecified), LineNum);
>+ } else if
>((_GET_CURRQEST_VARTINFO().mVarStoreId != EFI_VARSTORE_ID_INVALID)
>&& (_GET_CURRQEST_VARTINFO().mIsBitVar)) {
>+ LFlags |= (EDKII_IFR_NUMERIC_SIZE_BIT &
>(_GET_CURRQEST_VARSIZE()));
>+ _PCATCH(NObj.SetFlagsForBitField (HFlags,
>LFlags, IsDisplaySpecified), LineNum);
> }
>- _PCATCH(NObj.SetFlags (HFlags, LFlags,
>IsDisplaySpecified), LineNum);
> >>
> ;
>
>-numericFlagsField [UINT8 & HFlags, UINT8 & LFlags, BOOLEAN & IsSetType,
>BOOLEAN & IsDisplaySpecified] :
>+numericFlagsField [UINT8 & HFlags, UINT8 & LFlags, BOOLEAN & IsSetType,
>BOOLEAN & IsDisplaySpecified, UINT32 LineNum] :
> N:Number << _PCATCH(_STOU8(N->getText(), N-
>>getLine()) == 0 ? VFR_RETURN_SUCCESS : VFR_RETURN_UNSUPPORTED, N-
>>getLine()); >>
>- | "NUMERIC_SIZE_1" << $LFlags = ($LFlags &
>~EFI_IFR_NUMERIC_SIZE) | EFI_IFR_NUMERIC_SIZE_1; IsSetType = TRUE;>>
>- | "NUMERIC_SIZE_2" << $LFlags = ($LFlags &
>~EFI_IFR_NUMERIC_SIZE) | EFI_IFR_NUMERIC_SIZE_2; IsSetType = TRUE;>>
>- | "NUMERIC_SIZE_4" << $LFlags = ($LFlags &
>~EFI_IFR_NUMERIC_SIZE) | EFI_IFR_NUMERIC_SIZE_4; IsSetType = TRUE;>>
>- | "NUMERIC_SIZE_8" << $LFlags = ($LFlags &
>~EFI_IFR_NUMERIC_SIZE) | EFI_IFR_NUMERIC_SIZE_8; IsSetType = TRUE;>>
>- | "DISPLAY_INT_DEC" << $LFlags = ($LFlags &
>~EFI_IFR_DISPLAY) | EFI_IFR_DISPLAY_INT_DEC; IsDisplaySpecified = TRUE;>>
>- | "DISPLAY_UINT_DEC" << $LFlags = ($LFlags &
>~EFI_IFR_DISPLAY) | EFI_IFR_DISPLAY_UINT_DEC; IsDisplaySpecified =
>TRUE;>>
>- | "DISPLAY_UINT_HEX" << $LFlags = ($LFlags &
>~EFI_IFR_DISPLAY) | EFI_IFR_DISPLAY_UINT_HEX; IsDisplaySpecified =
>TRUE;>>
>+ | "NUMERIC_SIZE_1" << if
>(!_GET_CURRQEST_VARTINFO().mIsBitVar) {
>+ $LFlags = ($LFlags & ~EFI_IFR_NUMERIC_SIZE)
>| EFI_IFR_NUMERIC_SIZE_1;IsSetType = TRUE;
>+ } else {
>+ _PCATCH(VFR_RETURN_INVALID_PARAMETER,
>LineNum, "Can not specify the size of the numeric value for BIT field");
>+ }
>+ >>
>+ | "NUMERIC_SIZE_2" << if
>(!_GET_CURRQEST_VARTINFO().mIsBitVar) {
>+ $LFlags = ($LFlags & ~EFI_IFR_NUMERIC_SIZE)
>| EFI_IFR_NUMERIC_SIZE_2;IsSetType = TRUE;
>+ } else {
>+ _PCATCH(VFR_RETURN_INVALID_PARAMETER,
>LineNum, "Can not specify the size of the numeric value for BIT field");
>+ }
>+ >>
>+ | "NUMERIC_SIZE_4" << if
>(!_GET_CURRQEST_VARTINFO().mIsBitVar) {
>+ $LFlags = ($LFlags & ~EFI_IFR_NUMERIC_SIZE)
>| EFI_IFR_NUMERIC_SIZE_4; IsSetType = TRUE;
>+ } else {
>+ _PCATCH(VFR_RETURN_INVALID_PARAMETER,
>LineNum, "Can not specify the size of the numeric value for BIT field");
>+ }
>+ >>
>+ | "NUMERIC_SIZE_8" << if
>(!_GET_CURRQEST_VARTINFO().mIsBitVar) {
>+ $LFlags = ($LFlags & ~EFI_IFR_NUMERIC_SIZE)
>| EFI_IFR_NUMERIC_SIZE_8; IsSetType = TRUE;
>+ } else {
>+ _PCATCH(VFR_RETURN_INVALID_PARAMETER,
>LineNum, "Can not specify the size of the numeric value for BIT field");
>+ }
>+ >>
>+ | "DISPLAY_INT_DEC" << if
>(!_GET_CURRQEST_VARTINFO().mIsBitVar) {
>+ $LFlags = ($LFlags & ~EFI_IFR_DISPLAY) |
>EFI_IFR_DISPLAY_INT_DEC;
>+ } else {
>+ $LFlags = ($LFlags & ~EDKII_IFR_DISPLAY_BIT) |
>EDKII_IFR_DISPLAY_INT_DEC_BIT;
>+ }
>+ IsDisplaySpecified = TRUE;
>+ >>
>+ | "DISPLAY_UINT_DEC" << if
>(!_GET_CURRQEST_VARTINFO().mIsBitVar) {
>+ $LFlags = ($LFlags & ~EFI_IFR_DISPLAY) |
>EFI_IFR_DISPLAY_UINT_DEC;
>+ } else {
>+ $LFlags = ($LFlags & ~EDKII_IFR_DISPLAY_BIT) |
>EDKII_IFR_DISPLAY_UINT_DEC_BIT;
>+ }
>+ IsDisplaySpecified = TRUE;
>+ >>
>+ | "DISPLAY_UINT_HEX" << if
>(!_GET_CURRQEST_VARTINFO().mIsBitVar) {
>+ $LFlags = ($LFlags & ~EFI_IFR_DISPLAY) |
>EFI_IFR_DISPLAY_UINT_HEX;
>+ } else {
>+ $LFlags = ($LFlags & ~EDKII_IFR_DISPLAY_BIT) |
>EDKII_IFR_DISPLAY_UINT_HEX_BIT;
>+ }
>+ IsDisplaySpecified = TRUE;
>+ >>
> | 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] <<
>+ //
>+ // Create a GUID opcode to wrap the oneof
>opcode, if it refer to bit varstore.
>+ //
>+ if (_GET_CURRQEST_VARTINFO().mIsBitVar) {
>+ GuidObj = new CIfrGuid(0);
>+ GuidObj->SetGuid (&gEdkiiIfrBitVarGuid);
>+ 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) {
>+ LFlags = (EDKII_IFR_NUMERIC_SIZE_BIT &
>(_GET_CURRQEST_VARSIZE()));
>+ _PCATCH(OObj->SetFlagsForBitField (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]
> }
> <<
>- switch (_GET_CURRQEST_DATATYPE()) {
>+ if (!_GET_CURRQEST_VARTINFO().mIsBitVar) {
>+ 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 {
> //
>- // Base on the type to know the actual used
>size,shrink the buffer
>- // size allocate before.
>+ // Question stored in bit fields saved as UINT32
>type, so the ShrinkSize same as EFI_IFR_TYPE_NUM_SIZE_32.
> //
>- 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;
>+ ShrinkSize = 12;
> }
>- OObj.ShrinkBinSize (ShrinkSize);
>+ 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] :
> <<
> UINT8 LFlags = _GET_CURRQEST_DATATYPE() & EFI_IFR_NUMERIC_SIZE;
> UINT8 HFlags = 0;
>- EFI_VFR_VARSTORE_TYPE VarStoreType = EFI_VFR_VARSTORE_INVALID;
> BOOLEAN IsSetType = FALSE;
> BOOLEAN IsDisplaySpecified = FALSE;
>+ EFI_VFR_VARSTORE_TYPE VarStoreType =
>gCVfrDataStorage.GetVarStoreType
>(_GET_CURRQEST_VARTINFO().mVarStoreId);
> >>
>- numericFlagsField[HFlags, LFlags, IsSetType, IsDisplaySpecified] ( "\|"
>numericFlagsField[HFlags, LFlags, IsSetType, IsDisplaySpecified] )*
>+ numericFlagsField[HFlags, LFlags, IsSetType, IsDisplaySpecified, LineNum]
>( "\|" numericFlagsField[HFlags, LFlags, IsSetType, IsDisplaySpecified,
>LineNum] )*
> <<
> //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) {
>+ if
>(_GET_CURRQEST_VARTINFO().mVarStoreId != EFI_VARSTORE_ID_INVALID)
>{
>+ 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;
>+ _PCATCH(OObj.SetFlags (HFlags, LFlags),
>LineNum);
>+ } else if
>(_GET_CURRQEST_VARTINFO().mVarStoreId != EFI_VARSTORE_ID_INVALID)
>{
>+ _PCATCH(OObj.SetFlagsForBitField (HFlags,
>LFlags), LineNum);
> }
>- _PCATCH(OObj.SetFlags (HFlags, LFlags),
>LineNum);
> >>
> ;
>
> vfrStatementStringType :
> vfrStatementString |
>@@ -3379,26 +3747,30 @@ vfrStatementOneOfOption :
> Text "=" "STRING_TOKEN" "\(" S:Number "\)" ","
> Value "=" vfrConstantValueField[_GET_CURRQEST_DATATYPE(), *Val,
>ArrayType] ","
> <<
> if (gCurrentMinMaxData != NULL) {
> //set min/max value for oneof opcode
>- UINT64 Step = gCurrentMinMaxData-
>>GetStepData(_GET_CURRQEST_DATATYPE());
>- 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:
>+ UINT64 Step = gCurrentMinMaxData-
>>GetStepData(_GET_CURRQEST_DATATYPE(),
>_GET_CURRQEST_VARTINFO().mIsBitVar);
>+ if (_GET_CURRQEST_VARTINFO().mIsBitVar) {
> gCurrentMinMaxData-
>>SetMinMaxStepData(Val->u32, Val->u32, (UINT32) Step);
>- break;
>- case EFI_IFR_TYPE_NUM_SIZE_16:
>- gCurrentMinMaxData-
>>SetMinMaxStepData(Val->u16, Val->u16, (UINT16) Step);
>- break;
>- case EFI_IFR_TYPE_NUM_SIZE_8:
>- gCurrentMinMaxData-
>>SetMinMaxStepData(Val->u8, Val->u8, (UINT8) Step);
>- break;
>- default:
>- break;
>+ } 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:
>+ gCurrentMinMaxData-
>>SetMinMaxStepData(Val->u32, Val->u32, (UINT32) Step);
>+ break;
>+ case EFI_IFR_TYPE_NUM_SIZE_16:
>+ gCurrentMinMaxData-
>>SetMinMaxStepData(Val->u16, Val->u16, (UINT16) Step);
>+ break;
>+ case EFI_IFR_TYPE_NUM_SIZE_8:
>+ 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) {
>@@ -3428,24 +3800,35 @@ vfrStatementOneOfOption :
> break;
> default:
> break;
> }
> } else {
>- ReturnCode =
>gCVfrVarDataTypeDB.GetDataTypeSize (_GET_CURRQEST_DATATYPE(),
>&Size);
>+ //
>+ // For the oneof stored in bit fields, set the
>option type as UINT32.
>+ //
>+ 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());
> }
>
> Size += OFFSET_OF (EFI_IFR_ONE_OF_OPTION,
>Value);
> OOOObj = new CIfrOneOfOption((UINT8)Size);
> OOOObj->SetLineNo(L->getLine());
> OOOObj->SetOption (_STOSID(S->getText(), S-
>>getLine()));
> if (ArrayType) {
>- OOOObj->SetType (EFI_IFR_TYPE_BUFFER);
>+ OOOObj->SetType (EFI_IFR_TYPE_BUFFER);
> } else {
>- OOOObj->SetType
>(_GET_CURRQEST_DATATYPE());
>+ 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()]
> <<
>@@ -5220,11 +5603,12 @@ EfiVfrParser::_DeclareDefaultLinearVarStore (
> gCVfrDataStorage.DeclareBufferVarStore (
> TypeNameList[Index],
> &mFormsetGuid,
> &gCVfrVarDataTypeDB,
> TypeNameList[Index],
>- EFI_VARSTORE_ID_INVALID
>+ EFI_VARSTORE_ID_INVALID,
>+ FALSE
> );
> gCVfrDataStorage.GetVarStoreId(TypeNameList[Index], &VarStoreId,
>&mFormsetGuid);
> VSObj.SetVarStoreId (VarStoreId);
> gCVfrVarDataTypeDB.GetDataTypeSize(TypeNameList[Index], &Size);
> VSObj.SetSize ((UINT16) Size);
>@@ -5245,11 +5629,12 @@ EfiVfrParser::_DeclareDefaultLinearVarStore (
> gCVfrDataStorage.DeclareBufferVarStore (
> (CHAR8 *) DateName,
> &mFormsetGuid,
> &gCVfrVarDataTypeDB,
> (CHAR8 *) DateType,
>- EFI_VARSTORE_ID_INVALID
>+ EFI_VARSTORE_ID_INVALID,
>+ FALSE
> );
> gCVfrDataStorage.GetVarStoreId((CHAR8 *) DateName, &VarStoreId,
>&mFormsetGuid);
> VSObj.SetVarStoreId (VarStoreId);
> gCVfrVarDataTypeDB.GetDataTypeSize((CHAR8 *) DateType, &Size);
> VSObj.SetSize ((UINT16) Size);
>@@ -5266,11 +5651,12 @@ EfiVfrParser::_DeclareDefaultLinearVarStore (
> gCVfrDataStorage.DeclareBufferVarStore (
> (CHAR8 *) TimeName,
> &mFormsetGuid,
> &gCVfrVarDataTypeDB,
> (CHAR8 *) TimeType,
>- EFI_VARSTORE_ID_INVALID
>+ EFI_VARSTORE_ID_INVALID,
>+ FALSE
> );
> gCVfrDataStorage.GetVarStoreId((CHAR8 *) TimeName, &VarStoreId,
>&mFormsetGuid);
> VSObj.SetVarStoreId (VarStoreId);
> gCVfrVarDataTypeDB.GetDataTypeSize((CHAR8 *) TimeType, &Size);
> VSObj.SetSize ((UINT16) Size);
>diff --git a/BaseTools/Source/C/VfrCompile/VfrUtilityLib.cpp
>b/BaseTools/Source/C/VfrCompile/VfrUtilityLib.cpp
>index 37b58e2..b00a926 100644
>--- a/BaseTools/Source/C/VfrCompile/VfrUtilityLib.cpp
>+++ b/BaseTools/Source/C/VfrCompile/VfrUtilityLib.cpp
>@@ -598,10 +598,65 @@ CVfrVarDataTypeDB::ExtractStructTypeName (
> }
>
> return VFR_RETURN_SUCCESS;
> }
>
>+/**
>+ Check whether the DataType contain bit field.
>+
>+ @param TypeName The name of the type.
>+
>+**/
>+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;
>+}
>+
>+/**
>+ Check whether the field is bit field or not.
>+
>+ @param VarStr Point to the field name which may contain the structure
>name.
>+
>+**/
>+BOOLEAN
>+CVfrVarDataTypeDB::IsThisBitField (
>+ IN CHAR8 *VarStr
>+ )
>+{
>+ CHAR8 FName[MAX_NAME_LEN];
>+ CHAR8 TName[MAX_NAME_LEN];
>+ UINT32 ArrayIdx;
>+ SVfrDataType *pType = NULL;
>+ SVfrDataField *pField = NULL;
>+
>+ CHECK_ERROR_RETURN (ExtractStructTypeName (VarStr, TName),
>VFR_RETURN_SUCCESS);
>+ CHECK_ERROR_RETURN (GetDataType (TName, &pType),
>VFR_RETURN_SUCCESS);
>+
>+ 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;
>+ }
>+ if (pField->mIsBitField) {
>+ return TRUE;
>+ } else {
>+ return FALSE;
>+ }
>+}
>+
> EFI_VFR_RETURN_CODE
> CVfrVarDataTypeDB::ExtractFieldNameAndArrary (
> IN CHAR8 *&VarStr,
> IN CHAR8 *FName,
> OUT UINT32 &ArrayIdx
>@@ -695,11 +750,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 +783,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->mBitOffset + 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 +806,26 @@ CVfrVarDataTypeDB::GetFieldWidth (
> }
>
> UINT32
> CVfrVarDataTypeDB::GetFieldSize (
> IN SVfrDataField *Field,
>- IN UINT32 ArrayIdx
>+ IN UINT32 ArrayIdx,
>+ IN BOOLEAN BitField
> )
> {
> 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 (BitField) {
>+ return Field->mBitWidth;
>+ } else {
>+ return Field->mFieldType->mTotalSize;
>+ }
> }
> }
>
> VOID
> CVfrVarDataTypeDB::InternalTypesListInit (
>@@ -786,22 +850,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 +877,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 +905,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;
> }
>@@ -976,10 +1050,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
>@@ -1007,10 +1082,129 @@ CVfrVarDataTypeDB::SetNewTypeName (
>
> strcpy(mNewDataType->mTypeName, TypeName);
> return VFR_RETURN_SUCCESS;
> }
>
>+/**
>+ Record the bit field info in the data type.
>+
>+ @param FieldName Point to the field name.
>+ @param TypeName Point to the type name.
>+ @param Width The bit width.
>+ @param FieldInUnion The filed is in Union type or Structure type.
>+
>+**/
>+EFI_VFR_RETURN_CODE
>+CVfrVarDataTypeDB::DataTypeAddBitField (
>+ IN CHAR8 *FieldName,
>+ IN CHAR8 *TypeName,
>+ IN UINT32 Width,
>+ IN BOOLEAN FieldInUnion
>+ )
>+{
>+ SVfrDataField *pNewField = NULL;
>+ SVfrDataType *pFieldType = NULL;
>+ SVfrDataField *pTmp;
>+ UINT32 Align;
>+ UINT32 MaxDataTypeSize;
>+ BOOLEAN UpdateTotalSize;
>+
>+ CHECK_ERROR_RETURN (GetDataType (TypeName, &pFieldType),
>VFR_RETURN_SUCCESS);
>+
>+ if (Width > MAX_BIT_WIDTH) {
>+ return VFR_RETURN_BIT_WIDTH_ERROR;
>+ }
>+
>+ if (Width > pFieldType->mTotalSize * 8) {
>+ return VFR_RETURN_BIT_WIDTH_ERROR;
>+ }
>+
>+ if (FieldName != NULL && strlen (FieldName) >= MAX_NAME_LEN) {
>+ return VFR_RETURN_INVALID_PARAMETER;
>+ }
>+
>+ if (Width == 0 && FieldName != NULL) {
>+ return VFR_RETURN_INVALID_PARAMETER;
>+ }
>+
>+ for (pTmp = mNewDataType->mMembers; pTmp != NULL; pTmp = pTmp-
>>mNext) {
>+ if (FieldName != NULL && strcmp (pTmp->mFieldName, FieldName) == 0) {
>+ return VFR_RETURN_REDEFINED;
>+ }
>+ }
>+
>+ Align = MIN (mPackAlign, pFieldType->mAlign);
>+ UpdateTotalSize = FALSE;
>+
>+ if ((pNewField = new SVfrDataField) == NULL) {
>+ return VFR_RETURN_OUT_FOR_RESOURCES;
>+ }
>+
>+ MaxDataTypeSize = mNewDataType->mTotalSize;
>+ if (FieldName != NULL) {
>+ strcpy (pNewField->mFieldName, FieldName);
>+ }
>+ pNewField->mFieldType = pFieldType;
>+ pNewField->mIsBitField = TRUE;
>+ pNewField->mBitWidth = Width;
>+ pNewField->mArrayNum = 0;
>+ pNewField->mBitOffset = 0;
>+ pNewField->mOffset = 0;
>+
>+ if (mNewDataType->mMembers == NULL) {
>+ mNewDataType->mMembers = pNewField;
>+ pNewField->mNext = NULL;
>+ } else {
>+ for (pTmp = mNewDataType->mMembers; pTmp->mNext != NULL; pTmp
>= pTmp->mNext)
>+ ;
>+ pTmp->mNext = pNewField;
>+ pNewField->mNext = NULL;
>+ }
>+
>+ if (FieldInUnion) {
>+ pNewField->mOffset = 0;
>+ if (MaxDataTypeSize < pNewField->mFieldType->mTotalSize) {
>+ mNewDataType->mTotalSize = pNewField->mFieldType->mTotalSize;
>+ }
>+ } else {
>+ //
>+ // Check whether the bit fileds can be contained within one FieldType.
>+ //
>+ if (pTmp != NULL && pTmp->mIsBitField && strcmp (pTmp->mFieldType-
>>mTypeName, pNewField->mFieldType->mTypeName) == 0 &&
>+ (pTmp->mBitOffset - pTmp->mOffset * 8) + pTmp->mBitWidth +
>pNewField->mBitWidth <= pNewField->mFieldType->mTotalSize * 8) {
>+ pNewField->mBitOffset = pTmp->mBitOffset + pTmp->mBitWidth;
>+ pNewField->mOffset = pTmp->mOffset;
>+ //
>+ // If BitWidth=0,used to force alignment at the next word boundary.
>+ // So make this bit field occupy the remaing bit width of current field type.
>+ //
>+ if (pNewField->mBitWidth == 0) {
>+ pNewField->mBitWidth = pNewField->mFieldType->mTotalSize * 8 -
>(pNewField->mBitOffset - pTmp->mOffset * 8);
>+ }
>+ } else {
>+ //
>+ // The bit filed start a new memory
>+ //
>+ pNewField->mBitOffset = mNewDataType->mTotalSize * 8;
>+ UpdateTotalSize = TRUE;
>+ }
>+ }
>+
>+ if (UpdateTotalSize){
>+ if ((mNewDataType->mTotalSize % Align) == 0) {
>+ pNewField->mOffset = mNewDataType->mTotalSize;
>+ } else {
>+ pNewField->mOffset = mNewDataType->mTotalSize +
>ALIGN_STUFF(mNewDataType->mTotalSize, Align);
>+ }
>+ mNewDataType->mTotalSize = pNewField->mOffset + (pNewField-
>>mFieldType->mTotalSize);
>+ }
>+
>+ 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,
>@@ -1042,10 +1236,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);
> }
>@@ -1181,39 +1376,48 @@ CVfrVarDataTypeDB::GetDataTypeSize (
> EFI_VFR_RETURN_CODE
> CVfrVarDataTypeDB::GetDataFieldInfo (
> IN CHAR8 *VarStr,
> OUT UINT16 &Offset,
> OUT UINT8 &Type,
>- OUT UINT32 &Size
>+ OUT UINT32 &Size,
>+ OUT BOOLEAN &BitField
> )
> {
> CHAR8 TName[MAX_NAME_LEN], FName[MAX_NAME_LEN];
> UINT32 ArrayIdx, Tmp;
> SVfrDataType *pType = NULL;
> SVfrDataField *pField = NULL;
>+ CHAR8 *VarStrName;
>
> Offset = 0;
> Type = EFI_IFR_TYPE_OTHER;
> Size = 0;
>+ VarStrName = VarStr;
>
> CHECK_ERROR_RETURN (ExtractStructTypeName (VarStr, TName),
>VFR_RETURN_SUCCESS);
> CHECK_ERROR_RETURN (GetDataType (TName, &pType),
>VFR_RETURN_SUCCESS);
>
>+ BitField = IsThisBitField (VarStrName);
>+
> //
> // 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);
>+ CHECK_ERROR_RETURN(GetFieldOffset (pField, ArrayIdx, Tmp, pField-
>>mIsBitField), VFR_RETURN_SUCCESS);
>+ if (BitField && !pField->mIsBitField) {
>+ Offset = (UINT16) (Offset + Tmp * 8);
>+ } else {
>+ Offset = (UINT16) (Offset + Tmp);
>+ }
> Type = GetFieldWidth (pField);
>- Size = GetFieldSize (pField, ArrayIdx);
>+ Size = GetFieldSize (pField, ArrayIdx, BitField);
> }
> return VFR_RETURN_SUCCESS;
> }
>
> EFI_VFR_RETURN_CODE
>@@ -1358,10 +1562,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;
>@@ -1374,11 +1579,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 (
>@@ -1646,10 +1855,11 @@ CVfrDataStorage::DeclareBufferVarStore (
> IN CHAR8 *StoreName,
> IN EFI_GUID *Guid,
> IN CVfrVarDataTypeDB *DataTypeDB,
> IN CHAR8 *TypeName,
> IN EFI_VARSTORE_ID VarStoreId,
>+ IN BOOLEAN IsBitVarStore,
> IN BOOLEAN Flag
> )
> {
> SVfrVarStorageNode *pNew = NULL;
> SVfrDataType *pDataType = NULL;
>@@ -1672,11 +1882,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, IsBitVarStore, Flag)) == NULL) {
> return VFR_RETURN_OUT_FOR_RESOURCES;
> }
>
> pNew->mNext = mBufferVarStoreList;
> mBufferVarStoreList = pNew;
>@@ -2386,10 +2596,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
> )
>@@ -2397,10 +2608,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
>@@ -2410,10 +2622,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;
> }
>
>@@ -2424,11 +2637,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;
> }
>diff --git a/BaseTools/Source/C/VfrCompile/VfrUtilityLib.h
>b/BaseTools/Source/C/VfrCompile/VfrUtilityLib.h
>index 0c67d73..70af911 100644
>--- a/BaseTools/Source/C/VfrCompile/VfrUtilityLib.h
>+++ b/BaseTools/Source/C/VfrCompile/VfrUtilityLib.h
>@@ -20,11 +20,13 @@ WITHOUT WARRANTIES OR REPRESENTATIONS OF ANY
>KIND, EITHER EXPRESS OR IMPLIED.
> #include "Common/UefiBaseTypes.h"
> #include "EfiVfr.h"
> #include "VfrError.h"
>
> extern BOOLEAN VfrCompatibleMode;
>+static EFI_GUID gEdkiiIfrBitVarGuid = EDKII_IFR_BIT_VARSTORE_GUID;
>
>+#define MAX_BIT_WIDTH 32
> #define MAX_NAME_LEN 64
> #define MAX_STRING_LEN 0x100
> #define DEFAULT_ALIGN 1
> #define DEFAULT_PACK_ALIGN 0x8
> #define DEFAULT_NAME_TABLE_ITEMS 1024
>@@ -114,18 +116,22 @@ struct SVfrDataType;
> struct SVfrDataField {
> CHAR8 mFieldName[MAX_NAME_LEN];
> SVfrDataType *mFieldType;
> UINT32 mOffset;
> UINT32 mArrayNum;
>+ BOOLEAN mIsBitField;
>+ UINT8 mBitWidth;
>+ UINT32 mBitOffset;
> 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
>@@ -193,30 +199,33 @@ private:
> VOID InternalTypesListInit (VOID);
> VOID RegisterNewType (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, IN BOOLEAN);
>+ EFI_VFR_RETURN_CODE DataTypeAddBitField (IN CHAR8 *, IN CHAR8 *, IN
>UINT32, IN BOOLEAN);
> VOID DeclareDataTypeEnd (VOID);
>
> 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 &);
>+ EFI_VFR_RETURN_CODE GetDataFieldInfo (IN CHAR8 *, OUT UINT16 &,
>OUT UINT8 &, OUT UINT32 &, OUT BOOLEAN &);
>
> 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 IsThisBitField (IN CHAR8 *);
>
> BOOLEAN IsTypeNameDefined (IN CHAR8 *);
>
> VOID Dump(IN FILE *);
> //
>@@ -236,11 +245,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 +276,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 +293,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 *);
>@@ -341,11 +352,11 @@ public:
> EFI_VFR_RETURN_CODE NameTableAddItem (EFI_STRING_ID);
> 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 DeclareBufferVarStore (IN CHAR8 *, IN EFI_GUID
>*, IN CVfrVarDataTypeDB *, IN CHAR8 *, IN EFI_VARSTORE_ID, IN BOOLEAN,
>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
prev parent reply other threads:[~2017-09-21 7:33 UTC|newest]
Thread overview: 2+ messages / expand[flat|nested] mbox.gz Atom feed top
2017-09-21 7:20 [PATCH V7 1/6] BaseTool/VfrCompiler: Support Bit fields in EFI/Buffer VarStore Dandan Bi
2017-09-21 7:29 ` Gao, Liming [this message]
Reply instructions:
You may reply publicly to this message via plain-text email
using any one of the following methods:
* Save the following mbox file, import it into your mail client,
and reply-to-list from there: mbox
Avoid top-posting and favor interleaved quoting:
https://en.wikipedia.org/wiki/Posting_style#Interleaved_style
* Reply using the --to, --cc, and --in-reply-to
switches of git-send-email(1):
git send-email \
--in-reply-to=4A89E2EF3DFEDB4C8BFDE51014F606A14E15BA3B@SHSMSX152.ccr.corp.intel.com \
--to=devel@edk2.groups.io \
/path/to/YOUR_REPLY
https://kernel.org/pub/software/scm/git/docs/git-send-email.html
* If your mail client supports setting the In-Reply-To header
via mailto: links, try the mailto: link
Be sure your reply has a Subject: header at the top and a blank line
before the message body.
This is a public inbox, see mirroring instructions
for how to clone and mirror all data and code used for this inbox