sravan/system76-edk2
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity

Sync tool code to BuildTools project r1783.

Browse Source 
git-svn-id: https://edk2.svn.sourceforge.net/svnroot/edk2/trunk/edk2@9623 6f19259b-4bc3-4df7-8a09-765794883524
This commit is contained in:
lgao4
2009-12-29 06:16:53 +00:00
parent 4661d5df04
commit a709adfaf0
88 changed files with 2038 additions and 732 deletions
Download Patch File Download Diff File Expand all files Collapse all files

2
BaseTools/Source/C/VfrCompile/VfrFormPkg.cpp
View File

@@ -1301,6 +1301,7 @@ static struct {
{ 0, 0}, // 0x5D
{ sizeof (EFI_IFR_CATENATE), 0 }, // EFI_IFR_CATENATE_OP
{ sizeof (EFI_IFR_GUID), 0 }, // EFI_IFR_GUID_OP
{ sizeof (EFI_IFR_SECURITY), 0 }, // EFI_IFR_SECURITY_OP - 0x60
};
#ifdef CIFROBJ_DEUBG
@@ -1323,6 +1324,7 @@ static struct {
"EFI_IFR_STRING_REF1","EFI_IFR_STRING_REF2", "EFI_IFR_CONDITIONAL", "EFI_IFR_QUESTION_REF3", "EFI_IFR_ZERO", "EFI_IFR_ONE",
"EFI_IFR_ONES", "EFI_IFR_UNDEFINED", "EFI_IFR_LENGTH", "EFI_IFR_DUP", "EFI_IFR_THIS", "EFI_IFR_SPAN",
"EFI_IFR_VALUE", "EFI_IFR_DEFAULT", "EFI_IFR_DEFAULTSTORE", "EFI_IFR_INVALID", "EFI_IFR_CATENATE", "EFI_IFR_GUID",
"EFI_IFR_SECURITY",
};
VOID

178
BaseTools/Source/C/VfrCompile/VfrFormPkg.h
View File

@@ -398,49 +398,159 @@ public:
}
};
static CIfrQuestionHeader *gCurrentQuestion = NULL;
static CIfrObj *gCurrentIfrOpcode = NULL;
/*
* The definition of CIfrMinMaxStepData
*/
class CIfrMinMaxStepData {
private:
MINMAXSTEP_DATA *mMinMaxStepData;
BOOLEAN ValueIsSet;
BOOLEAN IsNumeric;
public:
CIfrMinMaxStepData (MINMAXSTEP_DATA *DataAddr) : mMinMaxStepData (DataAddr) {
CIfrMinMaxStepData (MINMAXSTEP_DATA *DataAddr, BOOLEAN NumericOpcode=FALSE) : mMinMaxStepData (DataAddr) {
mMinMaxStepData->u64.MinValue = 0;
mMinMaxStepData->u64.MaxValue = 0;
mMinMaxStepData->u64.Step = 0;
ValueIsSet = FALSE;
IsNumeric = NumericOpcode;
}
VOID SetMinMaxStepData (IN UINT64 MinValue, IN UINT64 MaxValue, IN UINT64 Step) {
mMinMaxStepData->u64.MinValue = MinValue;
mMinMaxStepData->u64.MaxValue = MaxValue;
mMinMaxStepData->u64.Step = Step;
if (!ValueIsSet) {
mMinMaxStepData->u64.MinValue = MinValue;
mMinMaxStepData->u64.MaxValue = MaxValue;
ValueIsSet = TRUE;
} else {
if (MinValue < mMinMaxStepData->u64.MinValue) {
mMinMaxStepData->u64.MinValue = MinValue;
}
if (MaxValue > mMinMaxStepData->u64.MaxValue) {
mMinMaxStepData->u64.MaxValue = MaxValue;
}
}
mMinMaxStepData->u64.Step = Step;
}
VOID SetMinMaxStepData (IN UINT32 MinValue, IN UINT32 MaxValue, IN UINT32 Step) {
mMinMaxStepData->u32.MinValue = MinValue;
mMinMaxStepData->u32.MaxValue = MaxValue;
mMinMaxStepData->u32.Step = Step;
if (!ValueIsSet) {
mMinMaxStepData->u32.MinValue = MinValue;
mMinMaxStepData->u32.MaxValue = MaxValue;
ValueIsSet = TRUE;
} else {
if (MinValue < mMinMaxStepData->u32.MinValue) {
mMinMaxStepData->u32.MinValue = MinValue;
}
if (MaxValue > mMinMaxStepData->u32.MaxValue) {
mMinMaxStepData->u32.MaxValue = MaxValue;
}
}
mMinMaxStepData->u32.Step = Step;
}
VOID SetMinMaxStepData (IN UINT16 MinValue, IN UINT16 MaxValue, IN UINT16 Step) {
mMinMaxStepData->u16.MinValue = MinValue;
mMinMaxStepData->u16.MaxValue = MaxValue;
mMinMaxStepData->u16.Step = Step;
if (!ValueIsSet) {
mMinMaxStepData->u16.MinValue = MinValue;
mMinMaxStepData->u16.MaxValue = MaxValue;
ValueIsSet = TRUE;
} else {
if (MinValue < mMinMaxStepData->u16.MinValue) {
mMinMaxStepData->u16.MinValue = MinValue;
}
if (MaxValue > mMinMaxStepData->u16.MaxValue) {
mMinMaxStepData->u16.MaxValue = MaxValue;
}
}
mMinMaxStepData->u16.Step = Step;
}
VOID SetMinMaxStepData (IN UINT8 MinValue, IN UINT8 MaxValue, IN UINT8 Step) {
mMinMaxStepData->u8.MinValue = MinValue;
mMinMaxStepData->u8.MaxValue = MaxValue;
mMinMaxStepData->u8.Step = Step;
if (!ValueIsSet) {
mMinMaxStepData->u8.MinValue = MinValue;
mMinMaxStepData->u8.MaxValue = MaxValue;
ValueIsSet = TRUE;
} else {
if (MinValue < mMinMaxStepData->u8.MinValue) {
mMinMaxStepData->u8.MinValue = MinValue;
}
if (MaxValue > mMinMaxStepData->u8.MaxValue) {
mMinMaxStepData->u8.MaxValue = MaxValue;
}
}
mMinMaxStepData->u8.Step = Step;
}
UINT64 GetMinData (UINT8 VarType) {
UINT64 MinValue = 0;
switch (VarType) {
case EFI_IFR_TYPE_NUM_SIZE_64:
MinValue = mMinMaxStepData->u64.MinValue;
break;
case EFI_IFR_TYPE_NUM_SIZE_32:
MinValue = (UINT64) mMinMaxStepData->u32.MinValue;
break;
case EFI_IFR_TYPE_NUM_SIZE_16:
MinValue = (UINT64) mMinMaxStepData->u16.MinValue;
break;
case EFI_IFR_TYPE_NUM_SIZE_8:
MinValue = (UINT64) mMinMaxStepData->u8.MinValue;
break;
default:
break;
}
return MinValue;
}
UINT64 GetMaxData (UINT8 VarType) {
UINT64 MaxValue = 0;
switch (VarType) {
case EFI_IFR_TYPE_NUM_SIZE_64:
MaxValue = mMinMaxStepData->u64.MaxValue;
break;
case EFI_IFR_TYPE_NUM_SIZE_32:
MaxValue = (UINT64) mMinMaxStepData->u32.MaxValue;
break;
case EFI_IFR_TYPE_NUM_SIZE_16:
MaxValue = (UINT64) mMinMaxStepData->u16.MaxValue;
break;
case EFI_IFR_TYPE_NUM_SIZE_8:
MaxValue = (UINT64) mMinMaxStepData->u8.MaxValue;
break;
default:
break;
}
return MaxValue;
}
UINT64 GetStepData (UINT8 VarType) {
UINT64 MaxValue = 0;
switch (VarType) {
case EFI_IFR_TYPE_NUM_SIZE_64:
MaxValue = mMinMaxStepData->u64.Step;
break;
case EFI_IFR_TYPE_NUM_SIZE_32:
MaxValue = (UINT64) mMinMaxStepData->u32.Step;
break;
case EFI_IFR_TYPE_NUM_SIZE_16:
MaxValue = (UINT64) mMinMaxStepData->u16.Step;
break;
case EFI_IFR_TYPE_NUM_SIZE_8:
MaxValue = (UINT64) mMinMaxStepData->u8.Step;
break;
default:
break;
}
return MaxValue;
}
BOOLEAN IsNumericOpcode () {
return IsNumeric;
}
};
static CIfrQuestionHeader *gCurrentQuestion = NULL;
static CIfrMinMaxStepData *gCurrentMinMaxData = NULL;
/*
* The definition of all of the UEFI IFR Objects
*/
@@ -979,15 +1089,15 @@ public:
CIfrNumeric () : CIfrObj (EFI_IFR_NUMERIC_OP, (CHAR8 **)&mNumeric),
CIfrOpHeader (EFI_IFR_NUMERIC_OP, &mNumeric->Header),
CIfrQuestionHeader (&mNumeric->Question),
CIfrMinMaxStepData (&mNumeric->data) {
CIfrMinMaxStepData (&mNumeric->data, TRUE) {
mNumeric->Flags = EFI_IFR_NUMERIC_SIZE_1 | EFI_IFR_DISPLAY_UINT_DEC;
gCurrentQuestion = this;
gCurrentIfrOpcode = this;
gCurrentQuestion = this;
gCurrentMinMaxData = this;
}
~CIfrNumeric () {
gCurrentQuestion = NULL;
gCurrentIfrOpcode = NULL;
gCurrentQuestion = NULL;
gCurrentMinMaxData = NULL;
}
EFI_VFR_RETURN_CODE SetFlags (IN UINT8 HFlags, IN UINT8 LFlags) {
@@ -1017,13 +1127,13 @@ public:
CIfrQuestionHeader (&mOneOf->Question),
CIfrMinMaxStepData (&mOneOf->data) {
mOneOf->Flags = 0;
gCurrentQuestion = this;
gCurrentIfrOpcode = this;
gCurrentQuestion = this;
gCurrentMinMaxData = this;
}
~CIfrOneOf () {
gCurrentQuestion = NULL;
gCurrentIfrOpcode = NULL;
gCurrentQuestion = NULL;
gCurrentMinMaxData = NULL;
}
EFI_VFR_RETURN_CODE SetFlags (IN UINT8 HFlags, IN UINT8 LFlags) {
@@ -1772,6 +1882,24 @@ public:
}
};
class CIfrSecurity : public CIfrObj, public CIfrOpHeader {
private:
EFI_IFR_SECURITY *mSecurity;
public:
CIfrSecurity (
IN UINT32 LineNo
) : CIfrObj (EFI_IFR_SECURITY_OP, (CHAR8 **)&mSecurity),
CIfrOpHeader (EFI_IFR_SECURITY_OP, &mSecurity->Header) {
SetLineNo (LineNo);
memset (&mSecurity->Permissions, 0, sizeof (EFI_GUID));
}
VOID SetPermissions (IN EFI_GUID *Permissions) {
memcpy (&mSecurity->Permissions, Permissions, sizeof (EFI_GUID));
}
};
class CIfrUint8 : public CIfrObj, public CIfrOpHeader {
private:
EFI_IFR_UINT8 *mUint8;

184
BaseTools/Source/C/VfrCompile/VfrSyntax.g
View File

@@ -1,5 +1,5 @@
/*++
Copyright (c) 2004 - 2008, Intel Corporation
Copyright (c) 2004 - 2009, Intel Corporation
All rights reserved. This program and the accompanying materials
are licensed and made available under the terms and conditions of the BSD License
which accompanies this distribution. The full text of the license may be found at
@@ -547,7 +547,8 @@ vfrFormSetList :
vfrStatementVarStoreEfi |
vfrStatementVarStoreNameValue |
vfrStatementDefaultStore |
vfrStatementDisableIfFormSet
vfrStatementDisableIfFormSet |
vfrStatementSuppressIfFormSet
)*
;
@@ -720,6 +721,21 @@ vfrStatementDisableIfFormSet :
";"
;
vfrStatementSuppressIfFormSet :
<< CIfrSuppressIf SIObj;>>
L:SuppressIf <<
if (mCompatibleMode) {
_PCATCH (VFR_RETURN_UNSUPPORTED, L);
}
SIObj.SetLineNo(L->getLine());
>>
{ FLAGS "=" flagsField ( "\|" flagsField )* "," }
vfrStatementExpression[0] ";"
vfrFormSetList
E: EndIf
";" << CRT_END_OP (E); >>
;
//*****************************************************************************
//
// the syntax of question header and statement header
@@ -1089,66 +1105,10 @@ vfrStatementDefault :
(
vfrStatementValue "," << IsExp = TRUE; DObj.SetScope (1); CIfrEnd EndObj1; EndObj1.SetLineNo(D->getLine()); >>
| "=" vfrConstantValueField[_GET_CURRQEST_DATATYPE()] > [Val] "," <<
if (gCurrentIfrOpcode != NULL && gCurrentIfrOpcode->GetObjBinAddr() != NULL) {
EFI_IFR_OP_HEADER *TempOpCode;
TempOpCode = (EFI_IFR_OP_HEADER *) gCurrentIfrOpcode->GetObjBinAddr();
switch (TempOpCode->OpCode) {
case EFI_IFR_NUMERIC_OP:
EFI_IFR_NUMERIC *TempNumricCode;
TempNumricCode = (EFI_IFR_NUMERIC *) TempOpCode;
switch (_GET_CURRQEST_DATATYPE()) {
case EFI_IFR_TYPE_NUM_SIZE_64:
if (Val.u64 < TempNumricCode->data.u64.MinValue || Val.u64 > TempNumricCode->data.u64.MaxValue) {
_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 (Val.u32 < TempNumricCode->data.u32.MinValue || Val.u32 > TempNumricCode->data.u32.MaxValue) {
_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 (Val.u16 < TempNumricCode->data.u16.MinValue || Val.u16 > TempNumricCode->data.u16.MaxValue) {
_PCATCH (VFR_RETURN_INVALID_PARAMETER, D->getLine(), "Numeric default value must be between MinValue and MaxValue.");
}
break;
case EFI_IFR_TYPE_NUM_SIZE_8:
if (Val.u8 < TempNumricCode->data.u8.MinValue || Val.u8 > TempNumricCode->data.u8.MaxValue) {
_PCATCH (VFR_RETURN_INVALID_PARAMETER, D->getLine(), "Numeric default value must be between MinValue and MaxValue.");
}
break;
}
break;
case EFI_IFR_ONE_OF_OP:
EFI_IFR_ONE_OF *TempOneOfCode;
TempOneOfCode = (EFI_IFR_ONE_OF *) TempOpCode;
if (TempOneOfCode->data.u64.MinValue != 0 || TempOneOfCode->data.u64.MaxValue != 0 || TempOneOfCode->data.u64.Step != 0) {
//OneOf MinMaxStep Data is set, Val value will be checked for MinMaxStep.
switch (_GET_CURRQEST_DATATYPE()) {
case EFI_IFR_TYPE_NUM_SIZE_64:
if (Val.u64 < TempOneOfCode->data.u64.MinValue || Val.u64 > TempOneOfCode->data.u64.MaxValue) {
_PCATCH (VFR_RETURN_INVALID_PARAMETER, D->getLine(), "OneOf default value must be between MinValue and MaxValue.");
}
break;
case EFI_IFR_TYPE_NUM_SIZE_32:
if (Val.u32 < TempOneOfCode->data.u32.MinValue || Val.u32 > TempOneOfCode->data.u32.MaxValue) {
_PCATCH (VFR_RETURN_INVALID_PARAMETER, D->getLine(), "OneOf default value must be between MinValue and MaxValue.");
}
break;
case EFI_IFR_TYPE_NUM_SIZE_16:
if (Val.u16 < TempOneOfCode->data.u16.MinValue || Val.u16 > TempOneOfCode->data.u16.MaxValue) {
_PCATCH (VFR_RETURN_INVALID_PARAMETER, D->getLine(), "OneOf default value must be between MinValue and MaxValue.");
}
break;
case EFI_IFR_TYPE_NUM_SIZE_8:
if (Val.u8 < TempOneOfCode->data.u8.MinValue || Val.u8 > TempOneOfCode->data.u8.MaxValue) {
_PCATCH (VFR_RETURN_INVALID_PARAMETER, D->getLine(), "OneOf default value must be between MinValue and MaxValue.");
}
break;
}
}
break;
if (gCurrentMinMaxData != NULL && gCurrentMinMaxData->IsNumericOpcode()) {
//check default value is valid for Numeric Opcode
if (Val.u64 < gCurrentMinMaxData->GetMinData(_GET_CURRQEST_DATATYPE()) || Val.u64 > gCurrentMinMaxData->GetMaxData(_GET_CURRQEST_DATATYPE())) {
_PCATCH (VFR_RETURN_INVALID_PARAMETER, D->getLine(), "Numeric default value must be between MinValue and MaxValue.");
}
}
DObj.SetType (_GET_CURRQEST_DATATYPE());
@@ -1711,7 +1671,7 @@ vfrSetMinMaxStep[CIfrMinMaxStepData & MMSDObj] :
>>
Minimum "=" I:Number ","
<<
switch (_GET_CURRQEST_DATATYPE ()) {
switch (_GET_CURRQEST_DATATYPE()) {
case EFI_IFR_TYPE_NUM_SIZE_64 : MinU8 = _STOU64(I->getText()); break;
case EFI_IFR_TYPE_NUM_SIZE_32 : MinU4 = _STOU32(I->getText()); break;
case EFI_IFR_TYPE_NUM_SIZE_16 : MinU2 = _STOU16(I->getText()); break;
@@ -1720,7 +1680,7 @@ vfrSetMinMaxStep[CIfrMinMaxStepData & MMSDObj] :
>>
Maximum "=" A:Number ","
<<
switch (_GET_CURRQEST_DATATYPE ()) {
switch (_GET_CURRQEST_DATATYPE()) {
case EFI_IFR_TYPE_NUM_SIZE_64 :
MaxU8 = _STOU64(A->getText());
if (MaxU8 < MinU8) {
@@ -1750,7 +1710,7 @@ vfrSetMinMaxStep[CIfrMinMaxStepData & MMSDObj] :
{
STEP "=" S:Number ","
<<
switch (_GET_CURRQEST_DATATYPE ()) {
switch (_GET_CURRQEST_DATATYPE()) {
case EFI_IFR_TYPE_NUM_SIZE_64 : StepU8 = _STOU64(S->getText()); break;
case EFI_IFR_TYPE_NUM_SIZE_32 : StepU4 = _STOU32(S->getText()); break;
case EFI_IFR_TYPE_NUM_SIZE_16 : StepU2 = _STOU16(S->getText()); break;
@@ -1759,7 +1719,7 @@ vfrSetMinMaxStep[CIfrMinMaxStepData & MMSDObj] :
>>
}
<<
switch (_GET_CURRQEST_DATATYPE ()) {
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;
@@ -1793,18 +1753,38 @@ vfrStatementNumeric :
vfrNumericFlags [CIfrNumeric & NObj, UINT32 LineNum] :
<<
UINT8 LFlags = _GET_CURRQEST_DATATYPE();
UINT8 LFlags = _GET_CURRQEST_DATATYPE() & EFI_IFR_NUMERIC_SIZE;
UINT8 HFlags = 0;
EFI_VFR_VARSTORE_TYPE VarStoreType = EFI_VFR_VARSTORE_INVALID;
>>
numericFlagsField[HFlags, LFlags] ( "\|" numericFlagsField[HFlags, LFlags] )*
<< _PCATCH(NObj.SetFlags (HFlags, LFlags), LineNum); >>
<<
//check data type flag
VarStoreType = mCVfrDataStorage.GetVarStoreType (_GET_CURRQEST_VARTINFO().mVarStoreId);
if (VarStoreType == EFI_VFR_VARSTORE_BUFFER || VarStoreType == EFI_VFR_VARSTORE_EFI) {
if (_GET_CURRQEST_DATATYPE() != (LFlags & EFI_IFR_NUMERIC_SIZE)) {
_PCATCH(VFR_RETURN_INVALID_PARAMETER, LineNum, "Numeric Flag is not same to Numeric VarData type");
}
} else {
// update data type for name/value store
UINT32 DataTypeSize;
_GET_CURRQEST_VARTINFO().mVarType = LFlags & EFI_IFR_NUMERIC_SIZE;
gCVfrVarDataTypeDB.GetDataTypeSize (_GET_CURRQEST_DATATYPE(), &DataTypeSize);
_GET_CURRQEST_VARTINFO().mVarTotalSize = DataTypeSize;
}
_PCATCH(NObj.SetFlags (HFlags, LFlags), LineNum);
>>
;
numericFlagsField [UINT8 & HFlags, UINT8 & LFlags] :
N:Number << _PCATCH(_STOU8(N->getText()) == 0 ? VFR_RETURN_SUCCESS : VFR_RETURN_UNSUPPORTED, N->getLine()); >>
| "DISPLAY_INT_DEC" << $LFlags |= 0x00; >>
| "DISPLAY_UINT_DEC" << $LFlags |= 0x10; >>
| "DISPLAY_UINT_HEX" << $LFlags |= 0x20; >>
| "NUMERIC_SIZE_1" << $LFlags = ($LFlags & ~EFI_IFR_NUMERIC_SIZE) | EFI_IFR_NUMERIC_SIZE_1; >>
| "NUMERIC_SIZE_2" << $LFlags = ($LFlags & ~EFI_IFR_NUMERIC_SIZE) | EFI_IFR_NUMERIC_SIZE_2; >>
| "NUMERIC_SIZE_4" << $LFlags = ($LFlags & ~EFI_IFR_NUMERIC_SIZE) | EFI_IFR_NUMERIC_SIZE_4; >>
| "NUMERIC_SIZE_8" << $LFlags = ($LFlags & ~EFI_IFR_NUMERIC_SIZE) | EFI_IFR_NUMERIC_SIZE_8; >>
| "DISPLAY_INT_DEC" << $LFlags = ($LFlags & ~EFI_IFR_DISPLAY) | EFI_IFR_DISPLAY_INT_DEC; >>
| "DISPLAY_UINT_DEC" << $LFlags = ($LFlags & ~EFI_IFR_DISPLAY) | EFI_IFR_DISPLAY_UINT_DEC; >>
| "DISPLAY_UINT_HEX" << $LFlags = ($LFlags & ~EFI_IFR_DISPLAY) | EFI_IFR_DISPLAY_UINT_HEX; >>
| questionheaderFlagsField[HFlags]
;
@@ -1832,11 +1812,27 @@ vfrStatementOneOf :
vfrOneofFlagsField [CIfrOneOf & OObj, UINT32 LineNum] :
<<
UINT8 LFlags = _GET_CURRQEST_DATATYPE();
UINT8 LFlags = _GET_CURRQEST_DATATYPE() & EFI_IFR_NUMERIC_SIZE;
UINT8 HFlags = 0;
EFI_VFR_VARSTORE_TYPE VarStoreType = EFI_VFR_VARSTORE_INVALID;
>>
numericFlagsField[HFlags, LFlags] ( "\|" numericFlagsField[HFlags, LFlags] )*
<< _PCATCH(OObj.SetFlags (HFlags, LFlags), LineNum); >>
<<
//check data type flag
VarStoreType = mCVfrDataStorage.GetVarStoreType (_GET_CURRQEST_VARTINFO().mVarStoreId);
if (VarStoreType == EFI_VFR_VARSTORE_BUFFER || VarStoreType == EFI_VFR_VARSTORE_EFI) {
if (_GET_CURRQEST_DATATYPE() != (LFlags & EFI_IFR_NUMERIC_SIZE)) {
_PCATCH(VFR_RETURN_INVALID_PARAMETER, LineNum, "Numeric Flag is not same to Numeric VarData type");
}
} else {
// update data type for Name/Value store
UINT32 DataTypeSize;
_GET_CURRQEST_VARTINFO().mVarType = LFlags & EFI_IFR_NUMERIC_SIZE;
gCVfrVarDataTypeDB.GetDataTypeSize (_GET_CURRQEST_DATATYPE(), &DataTypeSize);
_GET_CURRQEST_VARTINFO().mVarTotalSize = DataTypeSize;
}
_PCATCH(OObj.SetFlags (HFlags, LFlags), LineNum);
>>
;
vfrStatementStringType :
@@ -2080,10 +2076,9 @@ vfrStatementStatListOld :
vfrStatementDisableIfStat :
<<
CIfrDisableIf DIObj;
mConstantOnlyInExpression = TRUE;
>>
L:DisableIf << DIObj.SetLineNo(L->getLine()); >>
vfrStatementExpression[0] ";" << mConstantOnlyInExpression = FALSE; >>
vfrStatementExpression[0] ";"
( vfrStatementStatList )*
E:EndIf << CRT_END_OP (E); >>
";"
@@ -2227,10 +2222,9 @@ vfrStatementNoSubmitIf :
vfrStatementDisableIfQuest :
<<
CIfrDisableIf DIObj;
mConstantOnlyInExpression = TRUE;
>>
L:DisableIf << DIObj.SetLineNo(L->getLine()); >>
vfrStatementExpression[0] ";" << mConstantOnlyInExpression = FALSE; >>
vfrStatementExpression[0] ";"
vfrStatementQuestionOptionList
E:EndIf << CRT_END_OP (E); >>
;
@@ -2277,7 +2271,31 @@ vfrStatementOneOfOption :
>>
L:Option << OOOObj.SetLineNo(L->getLine()); >>
Text "=" "STRING_TOKEN" "\(" S:Number "\)" "," << OOOObj.SetOption (_STOSID(S->getText())); >>
Value "=" vfrConstantValueField[_GET_CURRQEST_DATATYPE()] >[Val] "," << OOOObj.SetType (_GET_CURRQEST_DATATYPE()); OOOObj.SetValue (Val); >>
Value "=" vfrConstantValueField[_GET_CURRQEST_DATATYPE()] >[Val] ","
<<
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:
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;
}
}
OOOObj.SetType (_GET_CURRQEST_DATATYPE());
OOOObj.SetValue (Val);
>>
F:FLAGS "=" vfrOneOfOptionFlags[OOOObj, F->getLine()]
<<
_PCATCH(mCVfrDataStorage.GetVarStoreName (_GET_CURRQEST_VARTINFO().mVarStoreId, &VarStoreName), L->getLine());
@@ -2460,6 +2478,7 @@ vfrStatementInvalidSaveRestoreDefaults :
#token RuleRef("ruleref") "ruleref"
#token StringRef("stringref") "stringref"
#token PushThis("pushthis") "pushthis"
#token Security("security") "security"
#token True("TRUE") "TRUE"
#token False("FALSE") "FALSE"
#token One("ONE") "ONE"
@@ -2685,6 +2704,7 @@ vfrExpressionBuildInFunction [UINT32 & RootLevel, UINT32 & ExpOpCount] :
| rulerefExp[$RootLevel, $ExpOpCount]
| stringref1Exp[$RootLevel, $ExpOpCount]
| pushthisExp[$RootLevel, $ExpOpCount]
| securityExp[$RootLevel, $ExpOpCount]
;
dupExp [UINT32 & RootLevel, UINT32 & ExpOpCount] :
@@ -2978,6 +2998,14 @@ pushthisExp[UINT32 & RootLevel, UINT32 & ExpOpCount] :
L:PushThis << { CIfrThis TObj(L->getLine()); _SAVE_OPHDR_COND (TObj, ($ExpOpCount == 0), L->getLine()); $ExpOpCount++; } >>
;
securityExp[UINT32 & RootLevel, UINT32 & ExpOpCount] :
<<
EFI_GUID Guid;
>>
L:Security
"\(" guidDefinition[Guid] "\)" << { CIfrSecurity SObj(L->getLine()); _SAVE_OPHDR_COND (SObj, ($ExpOpCount == 0), L->getLine()); SObj.SetPermissions (&Guid); } $ExpOpCount++; >>
;
vfrExpressionConstant[UINT32 & RootLevel, UINT32 & ExpOpCount] :
L1:True << CIfrTrue TObj(L1->getLine()); _SAVE_OPHDR_COND (TObj, ($ExpOpCount == 0), L1->getLine()); $ExpOpCount++; >>
| L2:False << CIfrFalse FObj(L2->getLine()); _SAVE_OPHDR_COND (FObj, ($ExpOpCount == 0), L2->getLine()); $ExpOpCount++; >>