X-Git-Url: https://git.proxmox.com/?p=mirror_edk2.git;a=blobdiff_plain;f=BaseTools%2FSource%2FC%2FVfrCompile%2FVfrSyntax.g;h=4c7c6f28ff4fdfeb68100b93d84bbf5c1f73a2a6;hp=c01f16e5d58303cf04c08c457eb5fa260dd34d1f;hb=5397bd425eba0cd00c5f76c8d35f328ca625db0e;hpb=fd171542e0aa89ac12a09d79608173f48019b14b
diff --git a/BaseTools/Source/C/VfrCompile/VfrSyntax.g b/BaseTools/Source/C/VfrCompile/VfrSyntax.g
index c01f16e5d5..4c7c6f28ff 100644
--- a/BaseTools/Source/C/VfrCompile/VfrSyntax.g
+++ b/BaseTools/Source/C/VfrCompile/VfrSyntax.g
@@ -1,6 +1,8 @@
-/*++
-Copyright (c) 2004 - 2008, Intel Corporation
-All rights reserved. This program and the accompanying materials
+/*++ @file
+Vfr Syntax
+
+Copyright (c) 2004 - 2017, 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
http://opensource.org/licenses/bsd-license.php
@@ -8,11 +10,6 @@ http://opensource.org/licenses/bsd-license.php
THE PROGRAM IS DISTRIBUTED UNDER THE BSD LICENSE ON AN "AS IS" BASIS,
WITHOUT WARRANTIES OR REPRESENTATIONS OF ANY KIND, EITHER EXPRESS OR IMPLIED.
-Module Name:
- VfrSyntax.g
-
-Abstract:
-
--*/
#header<<
@@ -26,6 +23,9 @@ Abstract:
>>
<<
+#ifdef UINT8_MAX
+#undef UINT8_MAX
+#endif
#include "stdio.h"
#include "PBlackBox.h"
#include "DLexerBase.h"
@@ -33,8 +33,8 @@ Abstract:
#include "AToken.h"
#define GET_LINENO(Obj) ((Obj)->getLine())
-#define SET_LINE_INFO(Obj, L) {(Obj).SetLineNo((L)->getLine());} while (0)
-#define CRT_END_OP(Obj) {CIfrEnd EObj; if (Obj != NULL) EObj.SetLineNo ((Obj)->getLine());} while (0)
+#define SET_LINE_INFO(Obj, L) do {(Obj).SetLineNo((L)->getLine());} while (0)
+#define CRT_END_OP(Obj) do {CIfrEnd EObj; if (Obj != NULL) EObj.SetLineNo ((Obj)->getLine());} while (0)
typedef ANTLRCommonToken ANTLRToken;
@@ -42,7 +42,7 @@ class CVfrDLGLexer : public VfrLexer
{
public:
CVfrDLGLexer (DLGFileInput *F) : VfrLexer (F) {};
- INT32 errstd (char *Text)
+ void errstd (const char *Text)
{
printf ("unrecognized input '%s'\n", Text);
}
@@ -51,11 +51,12 @@ public:
UINT8
VfrParserStart (
IN FILE *File,
- IN BOOLEAN CompatibleMode
+ IN INPUT_INFO_TO_SYNTAX *InputInfo
)
{
ParserBlackBox VfrParser(File);
- VfrParser.parser()->SetCompatibleMode (CompatibleMode);
+ VfrParser.parser()->SetCompatibleMode (InputInfo->CompatibleMode);
+ VfrParser.parser()->SetOverrideClassGuid (InputInfo->OverrideClassGuid);
return VfrParser.parser()->vfrProgram();
}
>>
@@ -131,7 +132,11 @@ VfrParserStart (
#token EndList("endlist") "endlist"
#token EndForm("endform") "endform"
#token Form("form") "form"
+#token FormMap("formmap") "formmap"
+#token MapTitle("maptitle") "maptitle"
+#token MapGuid("mapguid") "mapguid"
#token Subtitle("subtitle") "subtitle"
+#token EndSubtitle("endsubtitle") "endsubtitle"
#token Help("help") "help"
#token Text("text") "text"
#token Option("option") "option"
@@ -152,6 +157,7 @@ VfrParserStart (
#token Inventory("inventory") "inventory"
#token NonNvDataMap("_NON_NV_DATA_MAP") "_NON_NV_DATA_MAP"
#token Struct("struct") "struct"
+#token Union("union") "union"
#token Boolean("BOOLEAN") "BOOLEAN"
#token Uint64("UINT64") "UINT64"
#token Uint32("UINT32") "UINT32"
@@ -180,6 +186,7 @@ VfrParserStart (
#token Goto("goto") "goto"
#token FormSetGuid("formsetguid") "formsetguid"
#token InconsistentIf("inconsistentif") "inconsistentif"
+#token WarningIf("warningif") "warningif"
#token NoSubmitIf("nosubmitif") "nosubmitif"
#token EndIf("endif") "endif"
#token Key("key") "key"
@@ -188,6 +195,7 @@ VfrParserStart (
#token InteractiveFlag("INTERACTIVE") "INTERACTIVE"
#token NVAccessFlag("NV_ACCESS") "NV_ACCESS"
#token ResetRequiredFlag("RESET_REQUIRED") "RESET_REQUIRED"
+#token ReconnectRequiredFlag("RECONNECT_REQUIRED") "RECONNECT_REQUIRED"
#token LateCheckFlag("LATE_CHECK") "LATE_CHECK"
#token ReadOnlyFlag("READ_ONLY") "READ_ONLY"
#token OptionOnlyFlag("OPTIONS_ONLY") "OPTIONS_ONLY"
@@ -214,6 +222,8 @@ VfrParserStart (
#token Rule("rule") "rule"
#token EndRule("endrule") "endrule"
#token Value("value") "value"
+#token Read("read") "read"
+#token Write("write") "write"
#token ResetButton("resetbutton") "resetbutton"
#token EndResetButton("endresetbutton") "endresetbutton"
#token DefaultStore("defaultstore") "defaultstore"
@@ -228,6 +238,12 @@ VfrParserStart (
#token Refresh("refresh") "refresh"
#token Interval("interval") "interval"
#token VarstoreDevice("varstoredevice") "varstoredevice"
+#token GuidOp("guidop") "guidop"
+#token EndGuidOp("endguidop") "endguidop"
+#token DataType("datatype") "datatype"
+#token Data("data") "data"
+#token Modal("modal") "modal"
+
//
// Define the class and subclass tokens
//
@@ -250,12 +266,14 @@ VfrParserStart (
vfrProgram > [UINT8 Return] :
<<
- mParserStatus = 0;
+ mParserStatus = 0;
+ mCIfrOpHdrIndex = 0;
mConstantOnlyInExpression = FALSE;
>>
(
vfrPragmaPackDefinition
| vfrDataStructDefinition
+ | vfrDataUnionDefinition
)*
vfrFormSetDefinition
<< $Return = mParserStatus; >>
@@ -280,7 +298,7 @@ pragmaPackStackDef :
"," ID:StringIdentifier << Identifier = ID->getText(); >>
}
{
- "," N:Number << PackAction |= VFR_PACK_ASSIGN; PackNumber = _STOU32(N->getText()); >>
+ "," N:Number << PackAction |= VFR_PACK_ASSIGN; PackNumber = _STOU32(N->getText(), N->getLine()); >>
}
<< gCVfrVarDataTypeDB.Pack (LineNum, PackAction, Identifier, PackNumber); >>
;
@@ -290,7 +308,7 @@ pragmaPackNumber :
UINT32 LineNum;
UINT32 PackNumber = DEFAULT_PACK_ALIGN;
>>
- N:Number << LineNum = N->getLine(); PackNumber = _STOU32(N->getText()); >>
+ N:Number << LineNum = N->getLine(); PackNumber = _STOU32(N->getText(), N->getLine()); >>
<< gCVfrVarDataTypeDB.Pack (LineNum, VFR_PACK_ASSIGN, NULL, PackNumber); >>
;
@@ -304,6 +322,21 @@ vfrPragmaPackDefinition :
"\)"
;
+ vfrDataUnionDefinition :
+ { TypeDef } Union << gCVfrVarDataTypeDB.DeclareDataTypeBegin (); >>
+ { NonNvDataMap }
+ {
+ N1:StringIdentifier << _PCATCH(gCVfrVarDataTypeDB.SetNewTypeName (N1->getText()), N1); >>
+ }
+ OpenBrace
+ vfrDataStructFields[TRUE]
+ CloseBrace
+ {
+ N2:StringIdentifier << _PCATCH(gCVfrVarDataTypeDB.SetNewTypeName (N2->getText()), N2); >>
+ }
+ ";" << gCVfrVarDataTypeDB.DeclareDataTypeEnd ();>>
+ ;
+
vfrDataStructDefinition :
{ TypeDef } Struct << gCVfrVarDataTypeDB.DeclareDataTypeBegin (); >>
{ NonNvDataMap }
@@ -311,7 +344,7 @@ vfrDataStructDefinition :
N1:StringIdentifier << _PCATCH(gCVfrVarDataTypeDB.SetNewTypeName (N1->getText()), N1); >>
}
OpenBrace
- vfrDataStructFields
+ vfrDataStructFields[FALSE]
CloseBrace
{
N2:StringIdentifier << _PCATCH(gCVfrVarDataTypeDB.SetNewTypeName (N2->getText()), N2); >>
@@ -319,108 +352,202 @@ vfrDataStructDefinition :
";" << gCVfrVarDataTypeDB.DeclareDataTypeEnd (); >>
;
-vfrDataStructFields :
+vfrDataStructFields [BOOLEAN FieldInUnion]:
(
- dataStructField64 |
- dataStructField32 |
- dataStructField16 |
- dataStructField8 |
- dataStructFieldBool |
- dataStructFieldString |
- dataStructFieldDate |
- dataStructFieldTime |
- dataStructFieldUser
+ dataStructField64 [FieldInUnion] |
+ dataStructField32 [FieldInUnion] |
+ dataStructField16 [FieldInUnion] |
+ dataStructField8 [FieldInUnion] |
+ dataStructFieldBool [FieldInUnion] |
+ dataStructFieldString [FieldInUnion]|
+ dataStructFieldDate [FieldInUnion] |
+ dataStructFieldTime [FieldInUnion] |
+ dataStructFieldRef [FieldInUnion] |
+ dataStructFieldUser [FieldInUnion] |
+ dataStructBitField64 [FieldInUnion] |
+ dataStructBitField32 [FieldInUnion] |
+ dataStructBitField16 [FieldInUnion] |
+ dataStructBitField8 [FieldInUnion]
)*
;
-dataStructField64 :
+dataStructField64 [BOOLEAN FieldInUnion]:
<< UINT32 ArrayNum = 0; >>
- "UINT64"
+ D:"UINT64"
N:StringIdentifier
{
- OpenBracket I:Number CloseBracket << ArrayNum = _STOU32(I->getText()); >>
+ OpenBracket I:Number CloseBracket << ArrayNum = _STOU32(I->getText(), I->getLine()); >>
}
- ";" << _PCATCH(gCVfrVarDataTypeDB.DataTypeAddField (N->getText(), "UINT64", ArrayNum), N); >>
+ ";" << _PCATCH(gCVfrVarDataTypeDB.DataTypeAddField (N->getText(), D->getText(), ArrayNum, FieldInUnion), N); >>
;
-dataStructField32 :
+dataStructField32 [BOOLEAN FieldInUnion]:
<< UINT32 ArrayNum = 0; >>
- "UINT32"
+ D:"UINT32"
N:StringIdentifier
{
- OpenBracket I:Number CloseBracket << ArrayNum = _STOU32(I->getText()); >>
+ OpenBracket I:Number CloseBracket << ArrayNum = _STOU32(I->getText(), I->getLine()); >>
}
- ";" << _PCATCH(gCVfrVarDataTypeDB.DataTypeAddField (N->getText(), "UINT32", ArrayNum), N); >>
+ ";" << _PCATCH(gCVfrVarDataTypeDB.DataTypeAddField (N->getText(), D->getText(), ArrayNum, FieldInUnion), N); >>
;
-dataStructField16 :
- << UINT32 ArrayNum = 0; >>
+dataStructField16 [BOOLEAN FieldInUnion]:
+ <<
+ UINT32 ArrayNum = 0;
+ >>
("UINT16" | "CHAR16")
N:StringIdentifier
{
- OpenBracket I:Number CloseBracket << ArrayNum = _STOU32(I->getText()); >>
+ OpenBracket I:Number CloseBracket << ArrayNum = _STOU32(I->getText(), I->getLine()); >>
+ }
+ ";" << _PCATCH(gCVfrVarDataTypeDB.DataTypeAddField (N->getText(), (CHAR8 *) "UINT16", ArrayNum, FieldInUnion), N); >>
+ ;
+
+dataStructField8 [BOOLEAN FieldInUnion]:
+ << UINT32 ArrayNum = 0; >>
+ D:"UINT8"
+ N:StringIdentifier
+ {
+ OpenBracket I:Number CloseBracket << ArrayNum = _STOU32(I->getText(), I->getLine()); >>
}
- ";" << _PCATCH(gCVfrVarDataTypeDB.DataTypeAddField (N->getText(), "UINT16", ArrayNum), N); >>
+ ";" << _PCATCH(gCVfrVarDataTypeDB.DataTypeAddField (N->getText(), D->getText(), ArrayNum, FieldInUnion), N); >>
;
-dataStructField8 :
+dataStructFieldBool [BOOLEAN FieldInUnion]:
<< UINT32 ArrayNum = 0; >>
- "UINT8"
+ D:"BOOLEAN"
N:StringIdentifier
{
- OpenBracket I:Number CloseBracket << ArrayNum = _STOU32(I->getText()); >>
+ OpenBracket I:Number CloseBracket << ArrayNum = _STOU32(I->getText(), I->getLine()); >>
}
- ";" << _PCATCH(gCVfrVarDataTypeDB.DataTypeAddField (N->getText(), "UINT8", ArrayNum), N); >>
+ ";" << _PCATCH(gCVfrVarDataTypeDB.DataTypeAddField (N->getText(), D->getText(), ArrayNum, FieldInUnion), N); >>
;
-dataStructFieldBool :
+dataStructFieldString [BOOLEAN FieldInUnion]:
<< UINT32 ArrayNum = 0; >>
- "BOOLEAN"
+ D:"EFI_STRING_ID"
N:StringIdentifier
{
- OpenBracket I:Number CloseBracket << ArrayNum = _STOU32(I->getText()); >>
+ OpenBracket I:Number CloseBracket << ArrayNum = _STOU32(I->getText(), I->getLine()); >>
}
- ";" << _PCATCH(gCVfrVarDataTypeDB.DataTypeAddField (N->getText(), "BOOLEAN", ArrayNum), N); >>
+ ";" << _PCATCH(gCVfrVarDataTypeDB.DataTypeAddField (N->getText(), D->getText(), ArrayNum, FieldInUnion), N); >>
;
-dataStructFieldString :
+dataStructFieldDate [BOOLEAN FieldInUnion]:
<< UINT32 ArrayNum = 0; >>
- "EFI_STRING_ID"
+ D:"EFI_HII_DATE"
N:StringIdentifier
{
- OpenBracket I:Number CloseBracket << ArrayNum = _STOU32(I->getText()); >>
+ OpenBracket I:Number CloseBracket << ArrayNum = _STOU32(I->getText(), I->getLine()); >>
}
- ";" << _PCATCH(gCVfrVarDataTypeDB.DataTypeAddField (N->getText(), "EFI_STRING_ID", ArrayNum), N); >>
+ ";" << _PCATCH(gCVfrVarDataTypeDB.DataTypeAddField (N->getText(), D->getText(), ArrayNum, FieldInUnion), N); >>
;
-dataStructFieldDate :
+dataStructFieldTime [BOOLEAN FieldInUnion]:
<< UINT32 ArrayNum = 0; >>
- "EFI_HII_DATE"
+ D:"EFI_HII_TIME"
N:StringIdentifier
{
- OpenBracket I:Number CloseBracket << ArrayNum = _STOU32(I->getText()); >>
+ OpenBracket I:Number CloseBracket << ArrayNum = _STOU32(I->getText(), I->getLine()); >>
}
- ";" << _PCATCH(gCVfrVarDataTypeDB.DataTypeAddField (N->getText(), "EFI_HII_DATE", ArrayNum), N); >>
+ ";" << _PCATCH(gCVfrVarDataTypeDB.DataTypeAddField (N->getText(), D->getText(), ArrayNum, FieldInUnion), N); >>
;
-dataStructFieldTime :
+dataStructFieldRef [BOOLEAN FieldInUnion]:
<< UINT32 ArrayNum = 0; >>
- "EFI_HII_TIME"
+ D:"EFI_HII_REF"
N:StringIdentifier
{
- OpenBracket I:Number CloseBracket << ArrayNum = _STOU32(I->getText()); >>
+ OpenBracket I:Number CloseBracket << ArrayNum = _STOU32(I->getText(), I->getLine()); >>
}
- ";" << _PCATCH(gCVfrVarDataTypeDB.DataTypeAddField (N->getText(), "EFI_HII_TIME", ArrayNum), N); >>
+ ";" << _PCATCH(gCVfrVarDataTypeDB.DataTypeAddField (N->getText(), D->getText(), ArrayNum, FieldInUnion), N); >>
;
-dataStructFieldUser :
+dataStructFieldUser [BOOLEAN FieldInUnion]:
<< UINT32 ArrayNum = 0; >>
T:StringIdentifier
N:StringIdentifier
{
- OpenBracket I:Number CloseBracket << ArrayNum = _STOU32(I->getText()); >>
+ 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;>>
}
- ";" << _PCATCH(gCVfrVarDataTypeDB.DataTypeAddField (N->getText(), T->getText(), ArrayNum), T); >>
+ ":" 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);
+ }
+ >>
;
//*****************************************************************************
@@ -430,14 +557,14 @@ dataStructFieldUser :
guidSubDefinition [EFI_GUID &Guid] :
G4:Number "," G5:Number "," G6:Number "," G7:Number "," G8:Number "," G9:Number "," G10:Number "," G11:Number
<<
- Guid.Data4[0] = _STOU8(G4->getText());
- Guid.Data4[1] = _STOU8(G5->getText());
- Guid.Data4[2] = _STOU8(G6->getText());
- Guid.Data4[3] = _STOU8(G7->getText());
- Guid.Data4[4] = _STOU8(G8->getText());
- Guid.Data4[5] = _STOU8(G9->getText());
- Guid.Data4[6] = _STOU8(G10->getText());
- Guid.Data4[7] = _STOU8(G11->getText());
+ Guid.Data4[0] = _STOU8(G4->getText(), G4->getLine());
+ Guid.Data4[1] = _STOU8(G5->getText(), G5->getLine());
+ Guid.Data4[2] = _STOU8(G6->getText(), G6->getLine());
+ Guid.Data4[3] = _STOU8(G7->getText(), G7->getLine());
+ Guid.Data4[4] = _STOU8(G8->getText(), G8->getLine());
+ Guid.Data4[5] = _STOU8(G9->getText(), G9->getLine());
+ Guid.Data4[6] = _STOU8(G10->getText(), G10->getLine());
+ Guid.Data4[7] = _STOU8(G11->getText(), G11->getLine());
>>
;
@@ -445,9 +572,9 @@ guidDefinition [EFI_GUID &Guid] :
OpenBrace
G1:Number "," G2:Number "," G3:Number ","
<<
- Guid.Data1 = _STOU32 (G1->getText());
- Guid.Data2 = _STOU16 (G2->getText());
- Guid.Data3 = _STOU16 (G3->getText());
+ Guid.Data1 = _STOU32 (G1->getText(), G1->getLine());
+ Guid.Data2 = _STOU16 (G2->getText(), G2->getLine());
+ Guid.Data3 = _STOU16 (G3->getText(), G3->getLine());
>>
(
OpenBrace guidSubDefinition[Guid] CloseBrace
@@ -468,6 +595,7 @@ vfrFormSetDefinition :
UINT8 ClassGuidNum = 0;
CIfrFormSet *FSObj = NULL;
UINT16 C, SC;
+ CHAR8* InsertOpcodeAddr = NULL;
>>
L:FormSet
Uuid "=" guidDefinition[Guid] ","
@@ -476,34 +604,59 @@ vfrFormSetDefinition :
{
ClassGuid "=" guidDefinition[ClassGuid1] << ++ClassGuidNum; >>
{
- "\|" guidDefinition[ClassGuid2] << ++ClassGuidNum; >>
- }
- {
- "\|" guidDefinition[ClassGuid3] << ++ClassGuidNum; >>
+ "\|" guidDefinition[ClassGuid2] << ++ClassGuidNum; >>
+ {
+ "\|" guidDefinition[ClassGuid3] << ++ClassGuidNum; >>
+ }
}
","
}
<<
+ if (mOverrideClassGuid != NULL && ClassGuidNum >= 3) {
+ _PCATCH (VFR_RETURN_INVALID_PARAMETER, L->getLine(), "Already has 3 class guids, can't add extra class guid!");
+ }
switch (ClassGuidNum) {
case 0:
- FSObj = new CIfrFormSet(sizeof(EFI_IFR_FORM_SET));
+ if (mOverrideClassGuid != NULL) {
+ ClassGuidNum = 2;
+ } else {
+ ClassGuidNum = 1;
+ }
+ FSObj = new CIfrFormSet(sizeof(EFI_IFR_FORM_SET) + ClassGuidNum * sizeof(EFI_GUID));
FSObj->SetClassGuid(&DefaultClassGuid);
+ if (mOverrideClassGuid != NULL) {
+ FSObj->SetClassGuid(mOverrideClassGuid);
+ }
break;
case 1:
- FSObj = new CIfrFormSet(sizeof(EFI_IFR_FORM_SET));
+ if (mOverrideClassGuid != NULL) {
+ ClassGuidNum ++;
+ }
+ FSObj = new CIfrFormSet(sizeof(EFI_IFR_FORM_SET) + ClassGuidNum * sizeof(EFI_GUID));
FSObj->SetClassGuid(&ClassGuid1);
+ if (mOverrideClassGuid != NULL) {
+ FSObj->SetClassGuid(mOverrideClassGuid);
+ }
break;
case 2:
- FSObj = new CIfrFormSet(sizeof(EFI_IFR_FORM_SET) + sizeof(EFI_GUID));
+ if (mOverrideClassGuid != NULL) {
+ ClassGuidNum ++;
+ }
+ FSObj = new CIfrFormSet(sizeof(EFI_IFR_FORM_SET) + ClassGuidNum * sizeof(EFI_GUID));
FSObj->SetClassGuid(&ClassGuid1);
FSObj->SetClassGuid(&ClassGuid2);
+ if (mOverrideClassGuid != NULL) {
+ FSObj->SetClassGuid(mOverrideClassGuid);
+ }
break;
- default:
- FSObj = new CIfrFormSet(sizeof(EFI_IFR_FORM_SET) + 2 * sizeof(EFI_GUID));
+ case 3:
+ FSObj = new CIfrFormSet(sizeof(EFI_IFR_FORM_SET) + ClassGuidNum * sizeof(EFI_GUID));
FSObj->SetClassGuid(&ClassGuid1);
FSObj->SetClassGuid(&ClassGuid2);
FSObj->SetClassGuid(&ClassGuid3);
break;
+ default:
+ break;
}
SET_LINE_INFO (*FSObj, L);
@@ -514,8 +667,8 @@ vfrFormSetDefinition :
if (mCompatibleMode) {
memcpy (&mFormsetGuid, &Guid, sizeof (EFI_GUID));
}
- FSObj->SetFormSetTitle (_STOSID(S1->getText()));
- FSObj->SetHelp (_STOSID(S2->getText()));
+ FSObj->SetFormSetTitle (_STOSID(S1->getText(), S1->getLine()));
+ FSObj->SetHelp (_STOSID(S2->getText(), S2->getLine()));
>>
{
FC:Class "=" classDefinition[C] "," << {CIfrClass CObj;SET_LINE_INFO (CObj, FC); CObj.SetClass(C);} >>
@@ -534,7 +687,39 @@ vfrFormSetDefinition :
//
_DeclareDefaultFrameworkVarStore (GET_LINENO(E));
}
- CRT_END_OP (E); if (FSObj != NULL) delete FSObj;
+
+ //
+ // Declare undefined Question so that they can be used in expression.
+ //
+ if (gCFormPkg.HavePendingUnassigned()) {
+ mParserStatus += gCFormPkg.DeclarePendingQuestion (
+ gCVfrVarDataTypeDB,
+ gCVfrDataStorage,
+ mCVfrQuestionDB,
+ &mFormsetGuid,
+ E->getLine(),
+ &InsertOpcodeAddr
+ );
+ gNeedAdjustOpcode = TRUE;
+ }
+
+ CRT_END_OP (E);
+
+ //
+ // Adjust the pending question position.
+ // Move the position from current to before the end of the last form in the form set.
+ //
+ if (gNeedAdjustOpcode) {
+ gCFormPkg.AdjustDynamicInsertOpcode (
+ mLastFormEndAddr,
+ InsertOpcodeAddr,
+ FALSE
+ );
+ }
+
+ if (FSObj != NULL) {
+ delete FSObj;
+ }
>>
";"
;
@@ -542,31 +727,271 @@ vfrFormSetDefinition :
vfrFormSetList :
(
vfrFormDefinition |
+ vfrFormMapDefinition |
vfrStatementImage |
vfrStatementVarStoreLinear |
vfrStatementVarStoreEfi |
vfrStatementVarStoreNameValue |
vfrStatementDefaultStore |
- vfrStatementDisableIfFormSet
+ vfrStatementDisableIfFormSet |
+ vfrStatementSuppressIfFormSet |
+ vfrStatementExtension
)*
;
+vfrStatementExtension:
+ <<
+ EFI_GUID Guid;
+ CIfrGuid *GuidObj = NULL;
+ CHAR8 *TypeName = NULL;
+ UINT32 TypeSize = 0;
+ UINT8 *DataBuff = NULL;
+ UINT32 Size = 0;
+ UINT8 Idx = 0;
+ UINT32 LineNum;
+ BOOLEAN IsStruct = FALSE;
+ UINT32 ArrayNum = 0;
+ >>
+ L:GuidOp
+ Uuid "=" guidDefinition[Guid]
+ {"," DataType "="
+ (
+ U64:"UINT64" {OpenBracket AN1:Number CloseBracket <getText(), AN1->getLine());>>}
+ << TypeName = U64->getText(); LineNum = U64->getLine(); >>
+ | U32:"UINT32" {OpenBracket AN2:Number CloseBracket <getText(), AN2->getLine());>>}
+ << TypeName = U32->getText(); LineNum = U32->getLine(); >>
+ | U16:"UINT16" {OpenBracket AN3:Number CloseBracket <getText(), AN3->getLine());>>}
+ << TypeName = U16->getText(); LineNum = U16->getLine(); >>
+ | U8:"UINT8" {OpenBracket AN4:Number CloseBracket <getText(), AN4->getLine());>>}
+ << TypeName = U8->getText(); LineNum = U8->getLine(); >>
+ | BL:"BOOLEAN" {OpenBracket AN5:Number CloseBracket <getText(), AN5->getLine());>>}
+ << TypeName = BL->getText(); LineNum = BL->getLine(); >>
+ | SI:"EFI_STRING_ID" {OpenBracket AN6:Number CloseBracket <getText(), AN6->getLine());>>}
+ << TypeName = SI->getText(); LineNum = SI->getLine(); >>
+ | D:"EFI_HII_DATE" {OpenBracket AN7:Number CloseBracket <getText(), AN7->getLine());>>}
+ << TypeName = D->getText(); LineNum = D->getLine(); IsStruct = TRUE;>>
+ | T:"EFI_HII_TIME" {OpenBracket AN8:Number CloseBracket <getText(), AN8->getLine());>>}
+ << TypeName = T->getText(); LineNum = T->getLine(); IsStruct = TRUE;>>
+ | R:"EFI_HII_REF" {OpenBracket AN9:Number CloseBracket <getText(), AN9->getLine());>>}
+ << TypeName = R->getText(); LineNum = R->getLine(); IsStruct = TRUE;>>
+ | TN:StringIdentifier {OpenBracket AN10:Number CloseBracket <getText(), AN10->getLine());>>}
+ << TypeName = TN->getText(); LineNum = TN->getLine(); IsStruct = TRUE;>>
+ )
+ <<
+ _PCATCH(gCVfrVarDataTypeDB.GetDataTypeSize(TypeName, &TypeSize), LineNum);
+ if (ArrayNum > 0) {
+ Size = TypeSize*ArrayNum;
+ } else {
+ Size = TypeSize;
+ }
+ if (Size > (128 - sizeof (EFI_IFR_GUID))) return;
+ DataBuff = (UINT8 *)malloc(Size);
+ for (Idx = 0; Idx < Size; Idx++) {
+ DataBuff[Idx] = 0;
+ }
+ >>
+ vfrExtensionData [DataBuff, Size, TypeName, TypeSize, IsStruct, ArrayNum]
+ }
+ <<
+ {
+ GuidObj = new CIfrGuid(Size);
+ if (GuidObj != NULL) {
+ GuidObj->SetLineNo(L->getLine());
+ GuidObj->SetGuid (&Guid);
+ }
+ }
+ if (TypeName != NULL) {
+ GuidObj->SetData(DataBuff, Size);
+ }
+ >>
+ {","
+ (
+ vfrStatementExtension
+ )*
+ E:EndGuidOp << GuidObj->SetScope(1); CRT_END_OP (E); >>
+ }
+ <<
+ if (GuidObj != NULL) delete GuidObj;
+ if (DataBuff != NULL) free(DataBuff);
+ >>
+ ";"
+;
+
+vfrExtensionData[UINT8 *DataBuff, UINT32 Size, CHAR8 *TypeName, UINT32 TypeSize, BOOLEAN IsStruct, UINT32 ArrayNum]:
+ <<
+ CHAR8 *TFName = NULL;
+ UINT32 ArrayIdx = 0;
+ UINT16 FieldOffset;
+ UINT8 FieldType;
+ UINT32 FieldSize;
+ UINT64 Data_U64 = 0;
+ UINT32 Data_U32 = 0;
+ UINT16 Data_U16 = 0;
+ 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 <>}
+ <<
+ ArrayIdx = 0;
+ if (IsArray == TRUE) {
+ ArrayIdx = _STOU8(IDX1->getText(), IDX1->getLine());
+ if (ArrayIdx >= ArrayNum) return;
+ IsArray = FALSE;
+ }
+ ByteOffset = DataBuff + (ArrayIdx * TypeSize);
+ if (IsStruct == TRUE) {
+ _STRCAT(&TFName, TypeName);
+ }
+ >>
+ ("." FN:StringIdentifier
+ <<
+ if (IsStruct == TRUE) {
+ _STRCAT(&TFName, ".");
+ _STRCAT(&TFName, FN->getText());
+ }
+ >>
+ {
+ OpenBracket IDX2:Number CloseBracket
+ <<
+ if (IsStruct == TRUE) {
+ _STRCAT(&TFName, "[");
+ _STRCAT(&TFName, IDX2->getText());
+ _STRCAT(&TFName, "]");
+ }
+ >>
+ }
+ )*
+ "=" RD:Number
+ <<
+ if (IsStruct == FALSE) {
+ if (strcmp ("UINT64", TypeName) == 0) {
+ Data_U64 = _STOU64(RD->getText(), RD->getLine());
+ memcpy (ByteOffset, &Data_U64, TypeSize);
+ }else if (strcmp ("UINT32", TypeName) == 0) {
+ Data_U32 = _STOU32(RD->getText(), RD->getLine());
+ memcpy (ByteOffset, &Data_U32, TypeSize);
+ }else if (strcmp ("UINT16", TypeName) == 0) {
+ Data_U16 = _STOU16(RD->getText(), RD->getLine());
+ memcpy (ByteOffset, &Data_U16, TypeSize);
+ }else if (strcmp ("UINT8", TypeName) == 0) {
+ Data_U8 = _STOU8(RD->getText(), RD->getLine());
+ memcpy (ByteOffset, &Data_U8, TypeSize);
+ }else if (strcmp ("BOOLEAN", TypeName)== 0) {
+ Data_BL = _STOU8(RD->getText(), RD->getLine());
+ memcpy (ByteOffset, &Data_BL, 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, 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());
+ 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());
+ 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());
+ 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());
+ 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;
+ case EFI_IFR_TYPE_STRING:
+ Data_SID = _STOSID(RD->getText(), RD->getLine());
+ memcpy (ByteOffset + FieldOffset, &Data_SID, FieldSize);
+ break;
+ default:
+ break;
+ }
+ }
+ if (TFName != NULL) { delete TFName; TFName = NULL; }
+ >>
+ )*
+)
+;
+
+
vfrStatementDefaultStore :
<< UINT16 DefaultId = EFI_HII_DEFAULT_CLASS_STANDARD; >>
D:DefaultStore N:StringIdentifier ","
Prompt "=" "STRING_TOKEN" "\(" S:Number "\)"
{
- "," Attribute "=" A:Number << DefaultId = _STOU16(A->getText()); >>
+ "," Attribute "=" A:Number << DefaultId = _STOU16(A->getText(), A->getLine()); >>
}
<<
- if (mCVfrDefaultStore.DefaultIdRegistered (DefaultId) == FALSE) {
+ if (gCVfrDefaultStore.DefaultIdRegistered (DefaultId) == FALSE) {
CIfrDefaultStore DSObj;
- _PCATCH(mCVfrDefaultStore.RegisterDefaultStore (DSObj.GetObjBinAddr(), N->getText(), _STOSID(S->getText()), DefaultId)), D->getLine();
+ _PCATCH(gCVfrDefaultStore.RegisterDefaultStore (DSObj.GetObjBinAddr(), N->getText(), _STOSID(S->getText(), S->getLine()), DefaultId)), D->getLine();
DSObj.SetLineNo(D->getLine());
- DSObj.SetDefaultName (_STOSID(S->getText()));
+ DSObj.SetDefaultName (_STOSID(S->getText(), S->getLine()));
DSObj.SetDefaultId (DefaultId);
} else {
- _PCATCH(mCVfrDefaultStore.ReRegisterDefaultStoreById (DefaultId, N->getText(), _STOSID(S->getText()))), D->getLine();
+ _PCATCH(gCVfrDefaultStore.ReRegisterDefaultStoreById (DefaultId, N->getText(), _STOSID(S->getText(), S->getLine()))), D->getLine();
}
>>
";"
@@ -581,27 +1006,30 @@ vfrStatementVarStoreLinear :
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(); >>
- | U8:"UINT8" "," << TypeName = "UINT8"; LineNum = U8->getLine(); >>
- | U16:"UINT16" "," << TypeName = "UINT16"; LineNum = U16->getLine(); >>
- | U32:"UINT32" "," << TypeName = "UINT32"; LineNum = U32->getLine(); >>
- | U64:"UINT64" "," << TypeName = "UINT64"; LineNum = U64->getLine(); >>
- | D:"EFI_HII_DATE" "," << TypeName = "EFI_HII_DATE"; LineNum = D->getLine(); >>
- | T:"EFI_HII_TIME" "," << TypeName = "EFI_HII_TIME"; LineNum = T->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(); >>
+ | D:"EFI_HII_DATE" "," << TypeName = D->getText(); LineNum = D->getLine(); >>
+ | T:"EFI_HII_TIME" "," << TypeName = T->getText(); LineNum = T->getLine(); >>
+ | R:"EFI_HII_REF" "," << TypeName = R->getText(); LineNum = R->getLine(); >>
)
{ Key "=" FID:Number "," << // Key is used to assign Varid in Framework VFR but no use in UEFI2.1 VFR
if (mCompatibleMode) {
- VarStoreId = _STOU16(FID->getText());
+ VarStoreId = _STOU16(FID->getText(), FID->getLine());
}
>>
}
{
VarId "=" ID:Number "," <<
_PCATCH(
- (INTN)(VarStoreId = _STOU16(ID->getText())) != 0,
+ (INTN)(VarStoreId = _STOU16(ID->getText(), ID->getLine())) != 0,
(INTN)TRUE,
ID,
"varid 0 is not allowed."
@@ -616,18 +1044,19 @@ vfrStatementVarStoreLinear :
} else {
StoreName = SN->getText();
}
- _PCATCH(mCVfrDataStorage.DeclareBufferVarStore (
- StoreName,
- &Guid,
- &gCVfrVarDataTypeDB,
- TypeName,
- VarStoreId
- ), LineNum);
+ _PCATCH(gCVfrDataStorage.DeclareBufferVarStore (
+ StoreName,
+ &Guid,
+ &gCVfrVarDataTypeDB,
+ TypeName,
+ VarStoreId,
+ IsBitVarStore
+ ), LineNum);
VSObj.SetGuid (&Guid);
- _PCATCH(mCVfrDataStorage.GetVarStoreId(StoreName, &VarStoreId), SN);
+ _PCATCH(gCVfrDataStorage.GetVarStoreId(StoreName, &VarStoreId, &Guid), SN);
VSObj.SetVarStoreId (VarStoreId);
_PCATCH(gCVfrVarDataTypeDB.GetDataTypeSize(TypeName, &Size), LineNum);
- VSObj.SetSize (Size);
+ VSObj.SetSize ((UINT16) Size);
VSObj.SetName (SN->getText());
>>
";"
@@ -635,45 +1064,150 @@ vfrStatementVarStoreLinear :
vfrStatementVarStoreEfi :
<<
+ BOOLEAN IsUEFI23EfiVarstore = TRUE;
EFI_GUID Guid;
CIfrVarStoreEfi VSEObj;
- EFI_VARSTORE_ID VarStoreId;
+ EFI_VARSTORE_ID VarStoreId = EFI_VARSTORE_ID_INVALID;
UINT32 Attr = 0;
+ UINT32 Size;
+ CHAR8 *TypeName;
+ UINT32 LineNum;
+ CHAR8 *StoreName = NULL;
+ BOOLEAN CustomizedName = FALSE;
+ BOOLEAN IsBitVarStore = FALSE;
>>
E:Efivarstore << VSEObj.SetLineNo(E->getLine()); >>
- SN:StringIdentifier ","
+ (
+ 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(); >>
+ | D:"EFI_HII_DATE" "," << TypeName = D->getText(); LineNum = D->getLine(); >>
+ | T:"EFI_HII_TIME" "," << TypeName = T->getText(); LineNum = T->getLine(); >>
+ | R:"EFI_HII_REF" "," << TypeName = R->getText(); LineNum = R->getLine(); >>
+ )
+ {
+ VarId "=" ID:Number "," <<
+ _PCATCH(
+ (INTN)(VarStoreId = _STOU16(ID->getText(), ID->getLine())) != 0,
+ (INTN)TRUE,
+ ID,
+ "varid 0 is not allowed."
+ );
+ >>
+ }
Attribute "=" vfrVarStoreEfiAttr[Attr] ( "\|" vfrVarStoreEfiAttr[Attr] )* ","
<< VSEObj.SetAttributes (Attr); >>
- Name "=" "STRING_TOKEN" "\(" VN:Number "\)" ","
- VarSize "=" N:Number ","
- Uuid "=" guidDefinition[Guid] << mCVfrDataStorage.DeclareEfiVarStore (SN->getText(), &Guid, _STOSID(VN->getText()), _STOU32(N->getText())); >>
- <<
+
+ (
+ Name "=" SN:StringIdentifier "," << StoreName = SN->getText(); >>
+ |
+ Name "=" "STRING_TOKEN" "\(" VN:Number "\)" ","
+ VarSize "=" N:Number "," <<
+ IsUEFI23EfiVarstore = FALSE;
+ StoreName = gCVfrStringDB.GetVarStoreNameFormStringId(_STOSID(VN->getText(), VN->getLine()));
+ if (StoreName == NULL) {
+ _PCATCH (VFR_RETURN_UNSUPPORTED, VN->getLine(), "Can't get varstore name for this StringId!");
+ }
+ if (!CustomizedName) {
+ _PCATCH (VFR_RETURN_UNSUPPORTED, E->getLine(), "Old style efivarstore must have String Identifier!");
+ return;
+ }
+ Size = _STOU32(N->getText(), N->getLine());
+ switch (Size) {
+ case 1:
+ TypeName = (CHAR8 *) "UINT8";
+ break;
+ case 2:
+ TypeName = (CHAR8 *) "UINT16";
+ break;
+ case 4:
+ TypeName = (CHAR8 *) "UINT32";
+ break;
+ case 8:
+ TypeName = (CHAR8 *) "UINT64";
+ break;
+ default:
+ _PCATCH (VFR_RETURN_UNSUPPORTED, N);
+ break;
+ }
+ >>
+ )
+
+ Uuid "=" guidDefinition[Guid] <<
+ if (IsUEFI23EfiVarstore) {
+ _PCATCH(gCVfrDataStorage.DeclareBufferVarStore (
+ StoreName,
+ &Guid,
+ &gCVfrVarDataTypeDB,
+ TypeName,
+ VarStoreId,
+ IsBitVarStore
+ ), LineNum);
+ _PCATCH(gCVfrDataStorage.GetVarStoreId(StoreName, &VarStoreId, &Guid), SN);
+ _PCATCH(gCVfrVarDataTypeDB.GetDataTypeSize(TypeName, &Size), LineNum);
+ } else {
+ _PCATCH(gCVfrDataStorage.DeclareBufferVarStore (
+ TN->getText(),
+ &Guid,
+ &gCVfrVarDataTypeDB,
+ TypeName,
+ VarStoreId,
+ FALSE
+ ), LineNum);
+ _PCATCH(gCVfrDataStorage.GetVarStoreId(TN->getText(), &VarStoreId, &Guid), VN);
+ _PCATCH(gCVfrVarDataTypeDB.GetDataTypeSize(TypeName, &Size), N->getLine());
+ }
VSEObj.SetGuid (&Guid);
- _PCATCH(mCVfrDataStorage.GetVarStoreId(SN->getText(), &VarStoreId), SN);
VSEObj.SetVarStoreId (VarStoreId);
+
+ VSEObj.SetSize ((UINT16) Size);
+ VSEObj.SetName (StoreName);
+ if (IsUEFI23EfiVarstore == FALSE && StoreName != NULL) {
+ delete StoreName;
+ }
>>
";"
;
vfrVarStoreEfiAttr [UINT32 & Attr] :
- N:Number << $Attr |= _STOU32(N->getText()); >>
+ N:Number << $Attr |= _STOU32(N->getText(), N->getLine()); >>
;
vfrStatementVarStoreNameValue :
<<
EFI_GUID Guid;
CIfrVarStoreNameValue VSNVObj;
- EFI_VARSTORE_ID VarStoreId;
+ EFI_VARSTORE_ID VarStoreId = EFI_VARSTORE_ID_INVALID;
+ BOOLEAN Created = FALSE;
>>
L:NameValueVarStore << VSNVObj.SetLineNo(L->getLine()); >>
- SN:StringIdentifier "," << _PCATCH(mCVfrDataStorage.DeclareNameVarStoreBegin (SN->getText()), SN); >>
+ SN:StringIdentifier ","
+ {
+ VarId "=" ID:Number "," <<
+ _PCATCH(
+ (INTN)(VarStoreId = _STOU16(ID->getText(), ID->getLine())) != 0,
+ (INTN)TRUE,
+ ID,
+ "varid 0 is not allowed."
+ );
+ >>
+ }
(
- Name "=" "STRING_TOKEN" "\(" N:Number "\)" "," << _PCATCH(mCVfrDataStorage.NameTableAddItem (_STOSID(N->getText())), SN); >>
+ Name "=" "STRING_TOKEN" "\(" N:Number "\)" "," <<
+ if (!Created) {
+ _PCATCH(gCVfrDataStorage.DeclareNameVarStoreBegin (SN->getText(), VarStoreId), SN);
+ Created = TRUE;
+ }
+ _PCATCH(gCVfrDataStorage.NameTableAddItem (_STOSID(N->getText(), N->getLine())), SN);
+ >>
)+
- Uuid "=" guidDefinition[Guid] << _PCATCH(mCVfrDataStorage.DeclareNameVarStoreEnd (&Guid), SN); >>
+ Uuid "=" guidDefinition[Guid] << _PCATCH(gCVfrDataStorage.DeclareNameVarStoreEnd (&Guid), SN); >>
<<
VSNVObj.SetGuid (&Guid);
- _PCATCH(mCVfrDataStorage.GetVarStoreId(SN->getText(), &VarStoreId), SN);
+ _PCATCH(gCVfrDataStorage.GetVarStoreId(SN->getText(), &VarStoreId, &Guid), SN);
VSNVObj.SetVarStoreId (VarStoreId);
>>
";"
@@ -696,7 +1230,7 @@ validClassNames[UINT16 & Class] :
| ClassInputDevice << $Class |= EFI_INPUT_DEVICE_CLASS; >>
| ClassOnBoardDevice << $Class |= EFI_ON_BOARD_DEVICE_CLASS; >>
| ClassOtherDevice << $Class |= EFI_OTHER_DEVICE_CLASS; >>
- | N:Number << $Class |= _STOU16(N->getText()); >>
+ | N:Number << $Class |= _STOU16(N->getText(), N->getLine()); >>
;
subclassDefinition[UINT16 & SubClass] :
@@ -705,7 +1239,7 @@ subclassDefinition[UINT16 & SubClass] :
| SubclassGeneralApplication << $SubClass |= EFI_GENERAL_APPLICATION_SUBCLASS; >>
| SubclassFrontPage << $SubClass |= EFI_FRONT_PAGE_SUBCLASS; >>
| SubclassSingleUse << $SubClass |= EFI_SINGLE_USE_SUBCLASS; >>
- | N:Number << $SubClass |= _STOU16(N->getText()); >>
+ | N:Number << $SubClass |= _STOU16(N->getText(), N->getLine()); >>
;
vfrStatementDisableIfFormSet :
@@ -720,91 +1254,138 @@ 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
//
vfrStatementHeader[CIfrStatementHeader *SHObj] :
- Prompt "=" "STRING_TOKEN" "\(" S1:Number "\)" "," << $SHObj->SetPrompt (_STOSID(S1->getText())); >>
- Help "=" "STRING_TOKEN" "\(" S2:Number "\)" << $SHObj->SetHelp (_STOSID(S2->getText())); >>
+ 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;
>>
- {
- 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());
- _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;
- default:
- _PCATCH(VFR_RETURN_FATAL_ERROR);
- }
- $QHObj.SetQuestionId (QId);
- $QHObj.SetVarStoreInfo (&Info);
+ vfrQuestionBaseInfo[Info, QId, QType]
+ << $QHObj.SetQuestionId (QId);
+ if (Info.mVarStoreId != EFI_VARSTORE_ID_INVALID) {
+ $QHObj.SetVarStoreInfo (&Info);
+ }
>>
vfrStatementHeader[&$QHObj]
- << _SAVE_CURRQEST_VARINFO (Info); >>
- << if (VarIdStr != NULL) delete VarIdStr; >>
- ;
-
-vfrQuestionHeaderWithNoStorage[CIfrQuestionHeader *QHObj] :
- <<
- EFI_QUESTION_ID QId = EFI_QUESTION_ID_INVALID;
- CHAR8 *QName = NULL;
- >>
- {
- Name "=" QN:StringIdentifier "," <<
- QName = QN->getText();
- _PCATCH(mCVfrQuestionDB.FindQuestion (QName), VFR_RETURN_UNDEFINED, QN, "has already been used please used anther name");
- >>
- }
- {
- QuestionId "=" ID:Number "," <<
- QId = _STOQID(ID->getText());
- _PCATCH(mCVfrQuestionDB.FindQuestion (QId), VFR_RETURN_UNDEFINED, ID, "redefined quesiont ID");
- >>
- }
- <<
- mCVfrQuestionDB.RegisterQuestion (QName, NULL, QId);
- $QHObj->SetQuestionId (QId);
- >>
- vfrStatementHeader[$QHObj]
;
questionheaderFlagsField[UINT8 & Flags] :
ReadOnlyFlag << $Flags |= 0x01; >>
| InteractiveFlag << $Flags |= 0x04; >>
| ResetRequiredFlag << $Flags |= 0x10; >>
- | OptionOnlyFlag << $Flags |= 0x80; >>
- | NVAccessFlag
- | LateCheckFlag
+ | ReconnectRequiredFlag << $Flags |= 0x40; >>
+ | O:OptionOnlyFlag <<
+ if (mCompatibleMode) {
+ $Flags |= 0x80;
+ } else {
+ gCVfrErrorHandle.HandleWarning (
+ VFR_WARNING_OBSOLETED_FRAMEWORK_OPCODE,
+ O->getLine(),
+ O->getText()
+ );
+ }
+ >>
+ | N:NVAccessFlag <<
+ if (!mCompatibleMode) {
+ gCVfrErrorHandle.HandleWarning (
+ VFR_WARNING_OBSOLETED_FRAMEWORK_OPCODE,
+ N->getLine(),
+ N->getText()
+ );
+ }
+ >>
+ | L:LateCheckFlag <<
+ if (!mCompatibleMode) {
+ gCVfrErrorHandle.HandleWarning (
+ VFR_WARNING_OBSOLETED_FRAMEWORK_OPCODE,
+ L->getLine(),
+ L->getText()
+ );
+ }
+ >>
;
-vfrStorageVarId[EFI_VARSTORE_INFO & Info, CHAR8 *&QuestVarIdStr] :
+vfrStorageVarId[EFI_VARSTORE_INFO & Info, CHAR8 *&QuestVarIdStr, BOOLEAN CheckFlag = TRUE] :
<<
UINT32 Idx;
UINT32 LineNo;
@@ -815,40 +1396,45 @@ vfrStorageVarId[EFI_VARSTORE_INFO & Info, CHAR8 *&QuestVarIdStr] :
CHAR8 *TName = NULL;
EFI_VFR_RETURN_CODE VfrReturnCode = VFR_RETURN_SUCCESS;
EFI_IFR_TYPE_VALUE Dummy = gZeroEfiIfrTypeValue;
+ EFI_GUID *VarGuid = NULL;
>>
(
SN1:StringIdentifier << SName = SN1->getText(); _STRCAT(&VarIdStr, SN1->getText()); >>
OpenBracket I1:Number CloseBracket <<
- Idx = _STOU32(I1->getText());
+ Idx = _STOU32(I1->getText(), I1->getLine());
_STRCAT(&VarIdStr, "[");
_STRCAT(&VarIdStr, I1->getText());
_STRCAT(&VarIdStr, "]");
>>
<<
- VfrReturnCode = mCVfrDataStorage.GetVarStoreType (SName, VarStoreType);
+ VfrReturnCode = gCVfrDataStorage.GetVarStoreId(SName, &$Info.mVarStoreId);
if (mCompatibleMode && VfrReturnCode == VFR_RETURN_UNDEFINED) {
- mCVfrDataStorage.DeclareBufferVarStore (
+ gCVfrDataStorage.DeclareBufferVarStore (
SName,
&mFormsetGuid,
&gCVfrVarDataTypeDB,
SName,
EFI_VARSTORE_ID_INVALID,
+ FALSE,
FALSE
);
- VfrReturnCode = mCVfrDataStorage.GetVarStoreType (SName, VarStoreType);
+ VfrReturnCode = gCVfrDataStorage.GetVarStoreId(SName, &$Info.mVarStoreId, &mFormsetGuid);
+ }
+ if (CheckFlag || VfrReturnCode == VFR_RETURN_SUCCESS) {
+ _PCATCH(VfrReturnCode, SN1);
+ _PCATCH(gCVfrDataStorage.GetNameVarStoreInfo (&$Info, Idx), SN1);
}
- _PCATCH(VfrReturnCode, SN1);
- _PCATCH(mCVfrDataStorage.GetVarStoreId (SName, &$Info.mVarStoreId), SN1);
- _PCATCH(mCVfrDataStorage.GetNameVarStoreInfo (&$Info, Idx), SN1);
+
+ QuestVarIdStr = VarIdStr;
>>
)
|
(
SN2:StringIdentifier << SName = SN2->getText(); _STRCAT(&VarIdStr, SName); >>
<<
- VfrReturnCode = mCVfrDataStorage.GetVarStoreType (SName, VarStoreType);
+ VfrReturnCode = gCVfrDataStorage.GetVarStoreId(SName, &$Info.mVarStoreId);
if (mCompatibleMode && VfrReturnCode == VFR_RETURN_UNDEFINED) {
- mCVfrDataStorage.DeclareBufferVarStore (
+ gCVfrDataStorage.DeclareBufferVarStore (
SName,
&mFormsetGuid,
&gCVfrVarDataTypeDB,
@@ -856,25 +1442,29 @@ vfrStorageVarId[EFI_VARSTORE_INFO & Info, CHAR8 *&QuestVarIdStr] :
EFI_VARSTORE_ID_INVALID,
FALSE
);
- VfrReturnCode = mCVfrDataStorage.GetVarStoreType (SName, VarStoreType);
+ VfrReturnCode = gCVfrDataStorage.GetVarStoreId(SName, &$Info.mVarStoreId, &mFormsetGuid);
}
- _PCATCH(VfrReturnCode, SN2);
- _PCATCH(mCVfrDataStorage.GetVarStoreId (SName, &$Info.mVarStoreId), SN2);
- if (VarStoreType == EFI_VFR_VARSTORE_BUFFER) {
- _PCATCH(mCVfrDataStorage.GetBufferVarStoreDataTypeName(SName, &TName), SN2);
- _STRCAT(&VarStr, TName);
+ if (CheckFlag || VfrReturnCode == VFR_RETURN_SUCCESS) {
+ _PCATCH(VfrReturnCode, SN2);
+ VarStoreType = gCVfrDataStorage.GetVarStoreType ($Info.mVarStoreId);
+ if (VarStoreType == EFI_VFR_VARSTORE_BUFFER || VarStoreType == EFI_VFR_VARSTORE_BUFFER_BITS) {
+ _PCATCH(gCVfrDataStorage.GetBufferVarStoreDataTypeName(Info.mVarStoreId, &TName), SN2);
+ _STRCAT(&VarStr, TName);
+ }
}
>>
(
"." <<
- _PCATCH(((VarStoreType != EFI_VFR_VARSTORE_BUFFER) ? VFR_RETURN_EFIVARSTORE_USE_ERROR : VFR_RETURN_SUCCESS), SN2);
+ if (CheckFlag || VfrReturnCode == VFR_RETURN_SUCCESS) {
+ _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()); >>
{
OpenBracket I2:Number CloseBracket <<
- Idx = _STOU32(I2->getText());
+ Idx = _STOU32(I2->getText(), I2->getLine());
if (mCompatibleMode) Idx --;
if (Idx > 0) {
//
@@ -893,23 +1483,28 @@ vfrStorageVarId[EFI_VARSTORE_INFO & Info, CHAR8 *&QuestVarIdStr] :
)* <<
switch (VarStoreType) {
case EFI_VFR_VARSTORE_EFI:
- _PCATCH(mCVfrDataStorage.GetEfiVarStoreInfo (&$Info), SN2);
+ _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),
SN2->getLine());
_PCATCH((EFI_VFR_RETURN_CODE)gCVfrBufferConfig.Write (
'a',
SName,
+ VarGuid,
NULL,
$Info.mVarType,
$Info.mInfo.mVarOffset,
$Info.mVarTotalSize,
Dummy),
SN2->getLine());
+ _PCATCH(gCVfrDataStorage.AddBufferVarStoreFieldInfo(&$Info ),SN2->getLine());
break;
case EFI_VFR_VARSTORE_NAME:
default: break;
@@ -951,7 +1546,7 @@ vfrQuestionDataFieldName [EFI_QUESTION_ID &QId, UINT32 &Mask, CHAR8 *&VarIdStr,
SF:StringIdentifier << _STRCAT (&VarIdStr, SF->getText()); >>
{
OpenBracket I2:Number CloseBracket <<
- Idx = _STOU32(I2->getText());
+ Idx = _STOU32(I2->getText(), I2->getLine());
if (mCompatibleMode) Idx --;
if (Idx > 0) {
//
@@ -969,41 +1564,169 @@ vfrQuestionDataFieldName [EFI_QUESTION_ID &QId, UINT32 &Mask, CHAR8 *&VarIdStr,
)
;
-vfrConstantValueField[UINT8 Type] > [EFI_IFR_TYPE_VALUE Value] :
+vfrConstantValueField[UINT8 Type, EFI_IFR_TYPE_VALUE &Value, BOOLEAN &ListType] :
+ <<
+ EFI_GUID Guid;
+ BOOLEAN Negative = FALSE;
+ BOOLEAN IntDecStyle = FALSE;
+ CIfrNumeric *NumericQst = NULL;
+ if (gCurrentMinMaxData != NULL && gCurrentMinMaxData->IsNumericOpcode()) {
+ NumericQst = (CIfrNumeric *) gCurrentQuestion;
+ IntDecStyle = (NumericQst->GetNumericFlags() & EFI_IFR_DISPLAY) == 0 ? TRUE : FALSE;
+ }
+ UINT8 *Type8 = (UINT8 *) &Value;
+ UINT16 *Type16 = (UINT16 *) &Value;
+ UINT32 *Type32 = (UINT32 *) &Value;
+ UINT64 *Type64 = (UINT64 *) &Value;
+ UINT16 Index = 0;
+ ListType = FALSE;
+ >>
+ {
+ "\-" << Negative = TRUE; >>
+ }
N1:Number <<
- switch ($Type) {
- case EFI_IFR_TYPE_NUM_SIZE_8 :
- $Value.u8 = _STOU8(N1->getText());
- break;
- case EFI_IFR_TYPE_NUM_SIZE_16 :
- $Value.u16 = _STOU16(N1->getText());
- break;
- case EFI_IFR_TYPE_NUM_SIZE_32 :
- $Value.u32 = _STOU32(N1->getText());
- break;
- case EFI_IFR_TYPE_NUM_SIZE_64 :
- $Value.u64 = _STOU64(N1->getText());
- break;
- case EFI_IFR_TYPE_BOOLEAN :
- $Value.b = _STOU8(N1->getText());
- break;
- case EFI_IFR_TYPE_STRING :
- $Value.string = _STOU16(N1->getText());
- break;
- case EFI_IFR_TYPE_TIME :
- case EFI_IFR_TYPE_DATE :
- default :
- break;
+ //
+ // 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");
+ }
+ }
+ }
+ 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");
+ }
+ }
+ }
+ 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");
+ }
+ }
+ }
+ 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()); >>
- | O2:Ones << $Value.u64 = _STOU64(O2->getText()); >>
- | Z:Zero << $Value.u8 = _STOU8(Z->getText()); >>
- | HOUR:Number ":" MINUTE:Number ":" SECOND:Number << $Value.time = _STOT(HOUR->getText(), MINUTE->getText(), SECOND->getText()); >>
- | YEAR:Number "/" MONTH:Number "/" DAY:Number << $Value.date = _STOD(YEAR->getText(), MONTH->getText(), DAY->getText()); >>
- | "STRING_TOKEN" "\(" S1:Number "\)" << $Value.string = _STOSID(S1->getText()); >>
+ | O1:One << $Value.u8 = _STOU8(O1->getText(), O1->getLine()); >>
+ | O2:Ones << $Value.u64 = _STOU64(O2->getText(), O2->getLine()); >>
+ | Z:Zero << $Value.u8 = _STOU8(Z->getText(), Z->getLine()); >>
+ | HOUR:Number ":" MINUTE:Number ":" SECOND:Number << $Value.time = _STOT(HOUR->getText(), MINUTE->getText(),SECOND->getText(), HOUR->getLine()); >>
+ | YEAR:Number "/" MONTH:Number "/" DAY:Number << $Value.date = _STOD(YEAR->getText(), MONTH->getText(), DAY->getText(), YEAR->getLine()); >>
+ | QI:Number";" FI:Number";" guidDefinition[Guid] ";" "STRING_TOKEN" "\(" DP:Number "\)"
+ << $Value.ref = _STOR(QI->getText(), FI->getText(), &Guid, DP->getText(), QI->getLine()); >>
+ | "STRING_TOKEN" "\(" S1:Number "\)" << $Value.string = _STOSID(S1->getText(), S1->getLine()); >>
+ | "\{" << ListType = TRUE; >>
+ L1:Number <<
+ switch (Type) {
+ case EFI_IFR_TYPE_NUM_SIZE_8 :
+ Type8[Index] = _STOU8(L1->getText(), L1->getLine());
+ break;
+ case EFI_IFR_TYPE_NUM_SIZE_16 :
+ Type16[Index] = _STOU16(L1->getText(), L1->getLine());
+ break;
+ case EFI_IFR_TYPE_NUM_SIZE_32 :
+ Type32[Index] = _STOU32(L1->getText(), L1->getLine());
+ break;
+ case EFI_IFR_TYPE_NUM_SIZE_64 :
+ Type64[Index] = _STOU64(L1->getText(), L1->getLine());
+ break;
+ default:
+ break;
+ }
+ Index++;
+ >>
+ (
+ ","
+ L2:Number <<
+ switch (Type) {
+ case EFI_IFR_TYPE_NUM_SIZE_8 :
+ Type8[Index] = _STOU8(L2->getText(), L2->getLine());
+ break;
+ case EFI_IFR_TYPE_NUM_SIZE_16 :
+ Type16[Index] = _STOU16(L2->getText(), L2->getLine());
+ break;
+ case EFI_IFR_TYPE_NUM_SIZE_32 :
+ Type32[Index] = _STOU32(L2->getText(), L2->getLine());
+ break;
+ case EFI_IFR_TYPE_NUM_SIZE_64 :
+ Type64[Index] = _STOU64(L2->getText(), L2->getLine());
+ break;
+ default:
+ break;
+ }
+ Index++;
+ >>
+ )*
+ "\}"
;
//*****************************************************************************
@@ -1013,8 +1736,8 @@ vfrConstantValueField[UINT8 Type] > [EFI_IFR_TYPE_VALUE Value] :
vfrFormDefinition :
<< CIfrForm FObj; >>
F:Form << FObj.SetLineNo(F->getLine()); >>
- FormId "=" S1:Number "," << _PCATCH(FObj.SetFormId (_STOFID(S1->getText())), S1); >>
- Title "=" "STRING_TOKEN" "\(" S2:Number "\)" ";" << FObj.SetFormTitle (_STOSID(S2->getText())); >>
+ FormId "=" S1:Number "," << _PCATCH(FObj.SetFormId (_STOFID(S1->getText(), S1->getLine())), S1); >>
+ Title "=" "STRING_TOKEN" "\(" S2:Number "\)" ";" << FObj.SetFormTitle (_STOSID(S2->getText(), S2->getLine())); >>
(
vfrStatementImage |
vfrStatementLocked |
@@ -1026,7 +1749,10 @@ vfrFormDefinition :
vfrStatementLabel |
vfrStatementBanner |
// Just for framework vfr compatibility
- vfrStatementInvalid
+ vfrStatementInvalid |
+ vfrStatementExtension |
+ vfrStatementModal |
+ vfrStatementRefreshEvent ";"
)*
E:EndForm <<
if (mCompatibleMode) {
@@ -1042,27 +1768,43 @@ vfrFormDefinition :
CIfrLabel LObj3;
LObj3.SetLineNo(E->getLine());
LObj3.SetNumber (0xffff); //add end label for UEFI, label number hardcode 0xffff
- //
- // Declare undefined Question
- //
- if (gCFormPkg.HavePendingUnassigned()) {
- gCFormPkg.DeclarePendingQuestion (
- gCVfrVarDataTypeDB,
- mCVfrDataStorage,
- mCVfrQuestionDB,
- &mFormsetGuid,
- E->getLine()
- );
- }
}
- //
- // mCVfrQuestionDB.PrintAllQuestion();
- //
- CRT_END_OP (E);
+
+ {CIfrEnd EObj; EObj.SetLineNo (E->getLine()); mLastFormEndAddr = EObj.GetObjBinAddr(); gAdjustOpcodeOffset = EObj.GetObjBinOffset ();}
>>
";"
;
+vfrFormMapDefinition :
+ <<
+ CIfrFormMap *FMapObj = NULL;
+ UINT32 FormMapMethodNumber = 0;
+ EFI_GUID Guid;
+ >>
+ F:FormMap << FMapObj = new CIfrFormMap(); FMapObj->SetLineNo(F->getLine()); >>
+ FormId "=" S1:Number "," << _PCATCH(FMapObj->SetFormId (_STOFID(S1->getText(), S1->getLine())), S1); >>
+ (
+ MapTitle "=" "STRING_TOKEN" "\(" S2:Number "\)" ";"
+ MapGuid "=" guidDefinition[Guid] ";" << FMapObj->SetFormMapMethod (_STOFID(S2->getText(), S2->getLine()), &Guid); FormMapMethodNumber ++; >>
+ )* << if (FormMapMethodNumber == 0) {_PCATCH (VFR_RETURN_INVALID_PARAMETER, F->getLine(), "No MapMethod is set for FormMap!");} delete FMapObj;>>
+ (
+ vfrStatementImage |
+ vfrStatementLocked |
+ vfrStatementRules |
+ vfrStatementDefault |
+ vfrStatementStat |
+ vfrStatementQuestions |
+ vfrStatementConditional |
+ vfrStatementLabel |
+ vfrStatementBanner |
+ vfrStatementExtension |
+ vfrStatementModal |
+ vfrStatementRefreshEvent ";"
+ )*
+ E:EndForm << CRT_END_OP (E); >>
+ ";"
+ ;
+
vfrStatementRules :
<< CIfrRule RObj; >>
R:Rule << RObj.SetLineNo(R->getLine()); >>
@@ -1078,99 +1820,167 @@ vfrStatementRules :
vfrStatementDefault :
<<
BOOLEAN IsExp = FALSE;
- EFI_IFR_TYPE_VALUE Val = gZeroEfiIfrTypeValue;
- CIfrDefault DObj;
+ UINT64 ValueList[EFI_IFR_MAX_LENGTH] = {0,};
+ EFI_IFR_TYPE_VALUE *Val = (EFI_IFR_TYPE_VALUE *) ValueList;
+ CIfrDefault *DObj = NULL;
+ CIfrDefault2 *DObj2 = NULL;
EFI_DEFAULT_ID DefaultId = EFI_HII_DEFAULT_CLASS_STANDARD;
CHAR8 *VarStoreName = NULL;
EFI_VFR_VARSTORE_TYPE VarStoreType = EFI_VFR_VARSTORE_INVALID;
+ UINT32 Size = 0;
+ EFI_GUID *VarGuid = NULL;
+ BOOLEAN ArrayType = FALSE;
+ UINT8 *Type8 = (UINT8 *) ValueList;
+ UINT16 *Type16 = (UINT16 *) ValueList;
+ UINT32 *Type32 = (UINT32 *) ValueList;
+ UINT64 *Type64 = (UINT64 *) ValueList;
+ CIfrNumeric *NumericQst = NULL;
+
>>
- D:Default << DObj.SetLineNo(D->getLine()); >>
+ D:Default
(
(
- 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;
+ "=" 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 && !(_GET_CURRQEST_VARTINFO().mIsBitVar)) {
switch (_GET_CURRQEST_DATATYPE()) {
- case EFI_IFR_TYPE_NUM_SIZE_64:
- if (Val.u64 < TempNumricCode->data.u64.MinValue || Val.u64 > TempNumricCode->data.u64.MaxValue) {
+ case EFI_IFR_TYPE_NUM_SIZE_8:
+ 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_32:
- if (Val.u32 < TempNumricCode->data.u32.MinValue || Val.u32 > TempNumricCode->data.u32.MaxValue) {
+ case EFI_IFR_TYPE_NUM_SIZE_16:
+ 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_16:
- if (Val.u16 < TempNumricCode->data.u16.MinValue || Val.u16 > TempNumricCode->data.u16.MaxValue) {
+ case EFI_IFR_TYPE_NUM_SIZE_32:
+ 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_8:
- if (Val.u8 < TempNumricCode->data.u8.MinValue || Val.u8 > TempNumricCode->data.u8.MaxValue) {
+ case EFI_IFR_TYPE_NUM_SIZE_64:
+ 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;
}
- 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;
+ } else {
+ //
+ // 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.");
}
}
- break;
}
}
- DObj.SetType (_GET_CURRQEST_DATATYPE());
- DObj.SetValue(Val);
+ if (_GET_CURRQEST_DATATYPE() == EFI_IFR_TYPE_OTHER) {
+ _PCATCH (VFR_RETURN_FATAL_ERROR, D->getLine(), "Default data type error.");
+ Size = sizeof (EFI_IFR_TYPE_VALUE);
+ } else if (ArrayType) {
+ switch (_GET_CURRQEST_DATATYPE()) {
+ case EFI_IFR_TYPE_NUM_SIZE_8 :
+ while (Type8[Size] != 0) {
+ Size++;
+ }
+ break;
+ case EFI_IFR_TYPE_NUM_SIZE_16 :
+ while (Type16[Size] != 0) {
+ Size++;
+ }
+ Size *= sizeof (UINT16);
+ break;
+
+ case EFI_IFR_TYPE_NUM_SIZE_32 :
+ while (Type32[Size] != 0) {
+ Size++;
+ }
+ Size *= sizeof (UINT32);
+ break;
+
+ case EFI_IFR_TYPE_NUM_SIZE_64 :
+ while (Type64[Size] != 0) {
+ Size++;
+ }
+ Size *= sizeof (UINT64);
+ break;
+
+ default:
+ break;
+ }
+ } else {
+ 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 {
+ 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()); >>
)
{
- DefaultStore "=" SN:StringIdentifier "," << _PCATCH(mCVfrDefaultStore.GetDefaultId (SN->getText(), &DefaultId), SN); DObj.SetDefaultId (DefaultId); >>
+ DefaultStore "=" SN:StringIdentifier "," <<
+ _PCATCH(gCVfrDefaultStore.GetDefaultId (SN->getText(), &DefaultId), SN);
+ if (DObj != NULL) {
+ DObj->SetDefaultId (DefaultId);
+ }
+
+ if (DObj2 != NULL) {
+ DObj2->SetDefaultId (DefaultId);
+ }
+ >>
}
<<
- _PCATCH(mCVfrDataStorage.GetVarStoreName (_GET_CURRQEST_VARTINFO().mVarStoreId, &VarStoreName), D->getLine());
- _PCATCH(mCVfrDataStorage.GetVarStoreType (VarStoreName, VarStoreType), D->getLine());
+ CheckDuplicateDefaultValue (DefaultId, D);
+ if (_GET_CURRQEST_VARTINFO().mVarStoreId != EFI_VARSTORE_ID_INVALID) {
+ _PCATCH(gCVfrDataStorage.GetVarStoreName (_GET_CURRQEST_VARTINFO().mVarStoreId, &VarStoreName), D->getLine());
+ VarGuid = gCVfrDataStorage.GetVarStoreGuid(_GET_CURRQEST_VARTINFO().mVarStoreId);
+ VarStoreType = gCVfrDataStorage.GetVarStoreType (_GET_CURRQEST_VARTINFO().mVarStoreId);
if ((IsExp == FALSE) && (VarStoreType == EFI_VFR_VARSTORE_BUFFER)) {
- _PCATCH(mCVfrDefaultStore.BufferVarStoreAltConfigAdd (
+ _PCATCH(gCVfrDefaultStore.BufferVarStoreAltConfigAdd (
DefaultId,
_GET_CURRQEST_VARTINFO(),
VarStoreName,
+ VarGuid,
_GET_CURRQEST_DATATYPE (),
- Val),
+ *Val),
D->getLine()
);
+ }
}
+ if (DObj != NULL) {delete DObj;}
+ if (DObj2 != NULL) {delete DObj2;}
>>
)
;
@@ -1224,8 +2034,30 @@ vfrStatementInvalid :
;
flagsField :
- Number | InteractiveFlag | ManufacturingFlag | DefaultFlag |
- NVAccessFlag | ResetRequiredFlag | LateCheckFlag
+ Number
+ | InteractiveFlag
+ | ManufacturingFlag
+ | DefaultFlag
+ | ResetRequiredFlag
+ | ReconnectRequiredFlag
+ | N:NVAccessFlag <<
+ if (!mCompatibleMode) {
+ gCVfrErrorHandle.HandleWarning (
+ VFR_WARNING_OBSOLETED_FRAMEWORK_OPCODE,
+ N->getLine(),
+ N->getText()
+ );
+ }
+ >>
+ | L:LateCheckFlag <<
+ if (!mCompatibleMode) {
+ gCVfrErrorHandle.HandleWarning (
+ VFR_WARNING_OBSOLETED_FRAMEWORK_OPCODE,
+ L->getLine(),
+ L->getText()
+ );
+ }
+ >>
;
vfrStatementValue :
@@ -1234,15 +2066,33 @@ vfrStatementValue :
"=" vfrStatementExpression[0] << {CIfrEnd EndObj; EndObj.SetLineNo(V->getLine());} >>
;
+vfrStatementRead :
+ << CIfrRead RObj; >>
+ R:Read << RObj.SetLineNo(R->getLine()); >>
+ vfrStatementExpression[0] ";"
+ ;
+
+vfrStatementWrite :
+ << CIfrWrite WObj; >>
+ W:Write << WObj.SetLineNo(W->getLine()); >>
+ vfrStatementExpression[0] ";"
+ ;
+
vfrStatementSubTitle :
<< CIfrSubtitle SObj; >>
L:Subtitle << SObj.SetLineNo(L->getLine()); >>
- Text "=" "STRING_TOKEN" "\(" S:Number "\)" << SObj.SetPrompt (_STOSID(S->getText())); >>
+ Text "=" "STRING_TOKEN" "\(" S:Number "\)" << SObj.SetPrompt (_STOSID(S->getText(), S->getLine())); >>
{
"," FLAGS "=" vfrSubtitleFlags[SObj]
}
- { vfrStatementStatTagList "," }
- E:";" << CRT_END_OP (E); >>
+ (
+ {vfrStatementStatTagList "," }
+ E:";" << CRT_END_OP (E); >>
+ |
+ { "," vfrStatementStatTagList}
+ { "," (vfrStatementStat | vfrStatementQuestions)*}
+ D: EndSubtitle ";" << CRT_END_OP (D); >>
+ )
;
vfrSubtitleFlags [CIfrSubtitle & SObj] :
@@ -1252,7 +2102,7 @@ vfrSubtitleFlags [CIfrSubtitle & SObj] :
;
subtitleFlagsField [UINT8 & Flags] :
- N:Number << $Flags |= _STOU8(N->getText()); >>
+ N:Number << $Flags |= _STOU8(N->getText(), N->getLine()); >>
| "HORIZONTAL" << $Flags |= 0x01; >>
;
@@ -1266,7 +2116,7 @@ vfrStatementStaticText :
Help "=" "STRING_TOKEN" "\(" S1:Number "\)" ","
Text "=" "STRING_TOKEN" "\(" S2:Number "\)"
{
- "," Text "=" "STRING_TOKEN" "\(" S3:Number "\)" << TxtTwo = _STOSID(S3->getText()); >>
+ "," Text "=" "STRING_TOKEN" "\(" S3:Number "\)" << TxtTwo = _STOSID(S3->getText(), S3->getLine()); >>
}
{
"," F:FLAGS "=" staticTextFlagsField[Flags] ( "\|" staticTextFlagsField[Flags] )*
@@ -1274,20 +2124,27 @@ vfrStatementStaticText :
}
<<
if (Flags & EFI_IFR_FLAG_CALLBACK) {
+ if (TxtTwo != EFI_STRING_ID_INVALID) {
+ gCVfrErrorHandle.HandleWarning (
+ VFR_WARNING_ACTION_WITH_TEXT_TWO,
+ S3->getLine(),
+ S3->getText()
+ );
+ }
CIfrAction AObj;
mCVfrQuestionDB.RegisterQuestion (NULL, NULL, QId);
AObj.SetLineNo (F->getLine());
AObj.SetQuestionId (QId);
- AObj.SetPrompt (_STOSID(S2->getText()));
- AObj.SetHelp (_STOSID(S1->getText()));
+ AObj.SetPrompt (_STOSID(S2->getText(), S2->getLine()));
+ AObj.SetHelp (_STOSID(S1->getText(), S1->getLine()));
_PCATCH(AObj.SetFlags (Flags), F->getLine());
AssignQuestionKey (AObj, KN);
CRT_END_OP (KN);
} else {
CIfrText TObj;
TObj.SetLineNo (T->getLine());
- TObj.SetHelp (_STOSID(S1->getText()));
- TObj.SetPrompt (_STOSID(S2->getText()));
+ TObj.SetHelp (_STOSID(S1->getText(), S1->getLine()));
+ TObj.SetPrompt (_STOSID(S2->getText(), S2->getLine()));
TObj.SetTextTwo (TxtTwo);
}
>>
@@ -1296,7 +2153,7 @@ vfrStatementStaticText :
;
staticTextFlagsField[UINT8 & HFlags] :
- N:Number << _PCATCH(_STOU8(N->getText()) == 0 ? VFR_RETURN_SUCCESS : VFR_RETURN_UNSUPPORTED, N->getLine()); >>
+ N:Number << _PCATCH(_STOU8(N->getText(), N->getLine()) == 0 ? VFR_RETURN_SUCCESS : VFR_RETURN_UNSUPPORTED, N->getLine()); >>
| questionheaderFlagsField[HFlags]
;
@@ -1307,20 +2164,22 @@ vfrStatementCrossReference :
vfrStatementGoto :
<<
- UINT8 RefType = 1;
- EFI_STRING_ID DevPath;
- EFI_GUID FSId;
+ UINT8 RefType = 5;
+ EFI_STRING_ID DevPath = EFI_STRING_ID_INVALID;
+ EFI_GUID FSId = {0,};
EFI_FORM_ID FId;
EFI_QUESTION_ID QId = EFI_QUESTION_ID_INVALID;
UINT32 BitMask;
CIfrQuestionHeader *QHObj = NULL;
+ CIfrOpHeader *OHObj = NULL;
CIfrRef *R1Obj = NULL;
CIfrRef2 *R2Obj = NULL;
CIfrRef3 *R3Obj = NULL;
CIfrRef4 *R4Obj = NULL;
+ CIfrRef5 *R5Obj = NULL;
>>
G:Goto
- (
+ {
(
DevicePath "=" "STRING_TOKEN" "\(" P:Number "\)" ","
FormSetGuid "=" guidDefinition[FSId] ","
@@ -1328,9 +2187,9 @@ vfrStatementGoto :
Question "=" QN1:Number ","
<<
RefType = 4;
- DevPath = _STOSID(P->getText());
- FId = _STOFID(F1->getText());
- QId = _STOQID(QN1->getText());
+ DevPath = _STOSID(P->getText(), P->getLine());
+ FId = _STOFID(F1->getText(), F1->getLine());
+ QId = _STOQID(QN1->getText(), QN1->getLine());
>>
)
|
@@ -1340,33 +2199,47 @@ vfrStatementGoto :
Question "=" QN2:Number ","
<<
RefType = 3;
- FId = _STOFID(F2->getText());
- QId = _STOQID(QN2->getText());
+ FId = _STOFID(F2->getText(), F2->getLine());
+ QId = _STOQID(QN2->getText(), QN2->getLine());
>>
)
|
(
- FormId "=" F3:Number "," << RefType = 2; FId = _STOFID(F3->getText()); >>
+ FormId "=" F3:Number "," << RefType = 2; FId = _STOFID(F3->getText(), F3->getLine()); >>
Question "="
(
- QN3:StringIdentifier "," << mCVfrQuestionDB.GetQuestionId (QN3->getText (), NULL, QId, BitMask); >>
- | QN4:Number "," << QId = _STOQID(QN4->getText()); >>
+ QN3:StringIdentifier "," <<
+ mCVfrQuestionDB.GetQuestionId (QN3->getText (), NULL, QId, BitMask);
+ if (QId == EFI_QUESTION_ID_INVALID) {
+ _PCATCH(VFR_RETURN_UNDEFINED, QN3);
+ }
+ >>
+ | QN4:Number "," << QId = _STOQID(QN4->getText(), QN4->getLine()); >>
)
)
|
(
F4:Number "," <<
RefType = 1;
- FId = _STOFID(F4->getText());
+ FId = _STOFID(F4->getText(), F4->getLine());
>>
)
- )
+ }
<<
switch (RefType) {
+ case 5:
+ {
+ R5Obj = new CIfrRef5;
+ QHObj = R5Obj;
+ OHObj = R5Obj;
+ R5Obj->SetLineNo(G->getLine());
+ break;
+ }
case 4:
{
R4Obj = new CIfrRef4;
QHObj = R4Obj;
+ OHObj = R4Obj;
R4Obj->SetLineNo(G->getLine());
R4Obj->SetDevicePath (DevPath);
R4Obj->SetFormSetId (FSId);
@@ -1378,6 +2251,7 @@ vfrStatementGoto :
{
R3Obj = new CIfrRef3;
QHObj = R3Obj;
+ OHObj = R3Obj;
R3Obj->SetLineNo(G->getLine());
R3Obj->SetFormSetId (FSId);
R3Obj->SetFormId (FId);
@@ -1388,15 +2262,17 @@ vfrStatementGoto :
{
R2Obj = new CIfrRef2;
QHObj = R2Obj;
+ OHObj = R2Obj;
R2Obj->SetLineNo(G->getLine());
R2Obj->SetFormId (FId);
- _PCATCH(R2Obj->SetQuestionId (QId), QN3);
+ R2Obj->SetQuestionId (QId);
break;
}
case 1:
{
R1Obj = new CIfrRef;
QHObj = R1Obj;
+ OHObj = R1Obj;
R1Obj->SetLineNo(G->getLine());
R1Obj->SetFormId (FId);
break;
@@ -1404,13 +2280,20 @@ vfrStatementGoto :
default: break;
}
>>
- vfrQuestionHeaderWithNoStorage[QHObj]
- { "," vfrStatementStatTagList }
+ vfrQuestionHeader[*QHObj, QUESTION_REF] <<
+ if (_GET_CURRQEST_DATATYPE() == EFI_IFR_TYPE_OTHER) {
+ _GET_CURRQEST_VARTINFO().mVarType = EFI_IFR_TYPE_REF;
+ }
+ >>
{ "," F:FLAGS "=" vfrGotoFlags[QHObj, F->getLine()] }
{
"," Key "=" KN:Number << AssignQuestionKey (*QHObj, KN); >>
}
- ";" << if (R1Obj != NULL) {delete R1Obj;} if (R2Obj != NULL) {delete R2Obj;} if (R3Obj != NULL) {delete R3Obj;} if (R4Obj != NULL) {delete R4Obj;} >>
+ {
+ E:","
+ vfrStatementQuestionOptionList << OHObj->SetScope(1); CRT_END_OP (E);>>
+ }
+ ";" << if (R1Obj != NULL) {delete R1Obj;} if (R2Obj != NULL) {delete R2Obj;} if (R3Obj != NULL) {delete R3Obj;} if (R4Obj != NULL) {delete R4Obj;} if (R5Obj != NULL) {delete R5Obj;}>>
;
vfrGotoFlags [CIfrQuestionHeader *QHObj, UINT32 LineNum] :
@@ -1420,7 +2303,7 @@ vfrGotoFlags [CIfrQuestionHeader *QHObj, UINT32 LineNum] :
;
gotoFlagsField[UINT8 & HFlags] :
- N:Number << _PCATCH(_STOU8(N->getText()) == 0 ? VFR_RETURN_SUCCESS : VFR_RETURN_UNSUPPORTED, N->getLine()); >>
+ N:Number << _PCATCH(_STOU8(N->getText(), N->getLine()) == 0 ? VFR_RETURN_SUCCESS : VFR_RETURN_UNSUPPORTED, N->getLine()); >>
| questionheaderFlagsField[HFlags]
;
@@ -1438,7 +2321,7 @@ vfrStatementResetButton :
L:ResetButton << RBObj.SetLineNo(L->getLine()); >>
DefaultStore
"=" N:StringIdentifier "," <<
- _PCATCH(mCVfrDefaultStore.GetDefaultId (N->getText(), &DefaultId), N->getLine());
+ _PCATCH(gCVfrDefaultStore.GetDefaultId (N->getText(), &DefaultId), N->getLine());
RBObj.SetDefaultId (DefaultId);
>>
vfrStatementHeader[&RBObj] ","
@@ -1466,61 +2349,114 @@ vfrStatementBooleanType :
//
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
- _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 ((mCVfrDataStorage.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");
+ 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) {
+ //
+ // 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()] ","
<<
- _PCATCH(mCVfrDataStorage.GetVarStoreName (_GET_CURRQEST_VARTINFO().mVarStoreId, &VarStoreName), VFR_RETURN_SUCCESS, L, "Failed to retrieve varstore name");
- Val.b = TRUE;
- if (CBObj.GetFlags () & 0x01) {
- _PCATCH(
- mCVfrDefaultStore.BufferVarStoreAltConfigAdd (
- EFI_HII_DEFAULT_CLASS_STANDARD,
- _GET_CURRQEST_VARTINFO(),
- VarStoreName,
- _GET_CURRQEST_DATATYPE (),
- Val
- ),
- VFR_RETURN_SUCCESS,
- L,
- "No standard default storage found"
- );
- }
- if (CBObj.GetFlags () & 0x02) {
- _PCATCH(
- mCVfrDefaultStore.BufferVarStoreAltConfigAdd (
- EFI_HII_DEFAULT_CLASS_MANUFACTURING,
- _GET_CURRQEST_VARTINFO(),
- VarStoreName,
- _GET_CURRQEST_DATATYPE (),
- Val
- ),
- VFR_RETURN_SUCCESS,
- L,
- "No manufacturing default storage found"
- );
+ if (_GET_CURRQEST_VARTINFO().mVarStoreId != EFI_VARSTORE_ID_INVALID) {
+ _PCATCH(gCVfrDataStorage.GetVarStoreName (_GET_CURRQEST_VARTINFO().mVarStoreId, &VarStoreName), VFR_RETURN_SUCCESS, L, "Failed to retrieve varstore name");
+ VarStoreGuid = gCVfrDataStorage.GetVarStoreGuid(_GET_CURRQEST_VARTINFO().mVarStoreId);
+ Val.b = TRUE;
+ if (CBObj->GetFlags () & 0x01) {
+ CheckDuplicateDefaultValue (EFI_HII_DEFAULT_CLASS_STANDARD, F);
+ _PCATCH(
+ gCVfrDefaultStore.BufferVarStoreAltConfigAdd (
+ EFI_HII_DEFAULT_CLASS_STANDARD,
+ _GET_CURRQEST_VARTINFO(),
+ VarStoreName,
+ VarStoreGuid,
+ _GET_CURRQEST_DATATYPE (),
+ Val
+ ),
+ VFR_RETURN_SUCCESS,
+ L,
+ "No standard default storage found"
+ );
+ }
+ if (CBObj->GetFlags () & 0x02) {
+ CheckDuplicateDefaultValue (EFI_HII_DEFAULT_CLASS_MANUFACTURING, F);
+ _PCATCH(
+ gCVfrDefaultStore.BufferVarStoreAltConfigAdd (
+ EFI_HII_DEFAULT_CLASS_MANUFACTURING,
+ _GET_CURRQEST_VARTINFO(),
+ VarStoreName,
+ VarStoreGuid,
+ _GET_CURRQEST_DATATYPE (),
+ Val
+ ),
+ VFR_RETURN_SUCCESS,
+ L,
+ "No manufacturing default storage found"
+ );
+ }
}
>>
}
{
- 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;
+ >>
";"
;
@@ -1539,9 +2475,9 @@ checkboxFlagsField[UINT8 & LFlags, UINT8 & HFlags] :
//
// set question flag
//
- $LFlags |= _STOU8(N->getText());
+ $LFlags |= _STOU8(N->getText(), N->getLine());
} else {
- _PCATCH(_STOU8(N->getText()) == 0 ? VFR_RETURN_SUCCESS : VFR_RETURN_UNSUPPORTED, N->getLine());
+ _PCATCH(_STOU8(N->getText(), N->getLine()) == 0 ? VFR_RETURN_SUCCESS : VFR_RETURN_UNSUPPORTED, N->getLine());
}
>>
| D:"DEFAULT" <<
@@ -1583,9 +2519,9 @@ checkboxFlagsField[UINT8 & LFlags, UINT8 & HFlags] :
vfrStatementAction :
<< CIfrAction AObj; >>
L:Action << AObj.SetLineNo(L->getLine()); >>
- vfrQuestionHeaderWithNoStorage[&AObj] ","
+ vfrQuestionHeader[AObj] ","
{ F:FLAGS "=" vfrActionFlags[AObj, F->getLine()] "," }
- Config "=" "STRING_TOKEN" "\(" S:Number "\)" "," << AObj.SetQuestionConfig (_STOSID(S->getText())); >>
+ Config "=" "STRING_TOKEN" "\(" S:Number "\)" "," << AObj.SetQuestionConfig (_STOSID(S->getText(), S->getLine())); >>
vfrStatementQuestionTagList
E:EndAction << CRT_END_OP (E); >>
";"
@@ -1598,7 +2534,7 @@ vfrActionFlags[CIfrAction & AObj, UINT32 LineNum] :
;
actionFlagsField[UINT8 & HFlags] :
- N:Number << _PCATCH(_STOU8(N->getText()) == 0 ? VFR_RETURN_SUCCESS : VFR_RETURN_UNSUPPORTED, N->getLine()); >>
+ N:Number << _PCATCH(_STOU8(N->getText(), N->getLine()) == 0 ? VFR_RETURN_SUCCESS : VFR_RETURN_UNSUPPORTED, N->getLine()); >>
| questionheaderFlagsField[HFlags]
;
@@ -1608,11 +2544,16 @@ vfrStatementDate :
CHAR8 *VarIdStr[3] = {NULL, };
CIfrDate DObj;
EFI_IFR_TYPE_VALUE Val = gZeroEfiIfrTypeValue;
+ UINT8 Size = OFFSET_OF (EFI_IFR_DEFAULT, Value) + sizeof (EFI_HII_DATE);
>>
L:Date << DObj.SetLineNo(L->getLine()); >>
(
(
- vfrQuestionHeader[DObj, QUESTION_DATE] ","
+ vfrQuestionHeader[DObj, QUESTION_DATE] "," <<
+ if (_GET_CURRQEST_DATATYPE() == EFI_IFR_TYPE_OTHER) {
+ _GET_CURRQEST_VARTINFO().mVarType = EFI_IFR_TYPE_DATE;
+ }
+ >>
{ F:FLAGS "=" vfrDateFlags[DObj, F->getLine()] "," }
vfrStatementQuestionOptionList
)
@@ -1635,15 +2576,16 @@ vfrStatementDate :
Prompt "=" "STRING_TOKEN" "\(" DP:Number "\)" ","
Help "=" "STRING_TOKEN" "\(" DH:Number "\)" ","
minMaxDateStepDefault[Val.date, 2]
+ { G:FLAGS "=" vfrDateFlags[DObj, G->getLine()] "," }
<<
mCVfrQuestionDB.RegisterOldDateQuestion (VarIdStr[0], VarIdStr[1], VarIdStr[2], QId);
DObj.SetQuestionId (QId);
DObj.SetFlags (EFI_IFR_QUESTION_FLAG_DEFAULT, QF_DATE_STORAGE_TIME);
- DObj.SetPrompt (_STOSID(YP->getText()));
- DObj.SetHelp (_STOSID(YH->getText()));
+ DObj.SetPrompt (_STOSID(YP->getText(), YP->getLine()));
+ DObj.SetHelp (_STOSID(YH->getText(), YH->getLine()));
if (VarIdStr[0] != NULL) { delete VarIdStr[0]; } if (VarIdStr[1] != NULL) { delete VarIdStr[1]; } if (VarIdStr[2] != NULL) { delete VarIdStr[2]; }
>>
- << {CIfrDefault DefaultObj(EFI_HII_DEFAULT_CLASS_STANDARD, EFI_IFR_TYPE_DATE, Val); DefaultObj.SetLineNo(L->getLine());} >>
+ << {CIfrDefault DefaultObj(Size, EFI_HII_DEFAULT_CLASS_STANDARD, EFI_IFR_TYPE_DATE, Val); DefaultObj.SetLineNo(L->getLine());} >>
)
( vfrStatementInconsistentIf )*
)
@@ -1659,19 +2601,19 @@ minMaxDateStepDefault[EFI_HII_DATE & D, UINT8 KeyValue] :
"default" "=" N:Number "," <<
switch (KeyValue) {
case 0:
- D.Year = _STOU16(N->getText());
- if (D.Year < _STOU16 (MinN->getText()) || D.Year > _STOU16 (MaxN->getText())) {
+ D.Year = _STOU16(N->getText(), N->getLine());
+ if (D.Year < _STOU16 (MinN->getText(), MinN->getLine()) || D.Year > _STOU16 (MaxN->getText(), MaxN->getLine())) {
_PCATCH (VFR_RETURN_INVALID_PARAMETER, N->getLine(), "Year default value must be between Min year and Max year.");
}
break;
case 1:
- D.Month = _STOU8(N->getText());
+ D.Month = _STOU8(N->getText(), N->getLine());
if (D.Month < 1 || D.Month > 12) {
_PCATCH (VFR_RETURN_INVALID_PARAMETER, N->getLine(), "Month default value must be between 1 and 12.");
}
break;
case 2:
- D.Day = _STOU8(N->getText());
+ D.Day = _STOU8(N->getText(), N->getLine());
if (D.Day < 1 || D.Day > 31) {
_PCATCH (VFR_RETURN_INVALID_PARAMETER, N->getLine(), "Day default value must be between 1 and 31.");
}
@@ -1688,7 +2630,7 @@ vfrDateFlags [CIfrDate & DObj, UINT32 LineNum] :
;
dateFlagsField [UINT8 & Flags] :
- N:Number << $Flags |= _STOU8(N->getText()); >>
+ N:Number << $Flags |= _STOU8(N->getText(), N->getLine()); >>
| "YEAR_SUPPRESS" << $Flags |= 0x01; >>
| "MONTH_SUPPRESS" << $Flags |= 0x02; >>
| "DAY_SUPPRESS" << $Flags |= 0x04; >>
@@ -1708,135 +2650,553 @@ 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 (((_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;
>>
- Minimum "=" I:Number ","
- <<
- 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;
- case EFI_IFR_TYPE_NUM_SIZE_8 : MinU1 = _STOU8(I->getText()); break;
+ Minimum "="
+ {
+ "\-" << MinNegative = TRUE; >>
+ }
+ I:Number "," <<
+ if (!IntDecStyle && MinNegative) {
+ _PCATCH (VFR_RETURN_INVALID_PARAMETER, I->getLine(), "\"-\" can't be used when not in int decimal type. ");
}
- >>
- Maximum "=" A:Number ","
- <<
- switch (_GET_CURRQEST_DATATYPE ()) {
- case EFI_IFR_TYPE_NUM_SIZE_64 :
- MaxU8 = _STOU64(A->getText());
- if (MaxU8 < MinU8) {
- _PCATCH (VFR_RETURN_INVALID_PARAMETER, A->getLine(), "Maximum can't be less than Minimum");
+ //
+ // 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 && 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_32 :
- MaxU4 = _STOU32(A->getText());
- if (MaxU4 < MinU4) {
- _PCATCH (VFR_RETURN_INVALID_PARAMETER, A->getLine(), "Maximum can't be less than Minimum");
+ } 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");
+ }
+ }
+ }
+ 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) {
+ 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");
+ }
+ }
+ }
+ 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;
}
- break;
- case EFI_IFR_TYPE_NUM_SIZE_16 :
- MaxU2 = _STOU16(A->getText());
- if (MaxU2 < MinU2) {
- _PCATCH (VFR_RETURN_INVALID_PARAMETER, A->getLine(), "Maximum can't be less than Minimum");
+ }
+ >>
+ Maximum "="
+ {
+ "\-" << MaxNegative = TRUE; >>
+ }
+ A:Number "," <<
+ if (!IntDecStyle && MaxNegative) {
+ _PCATCH (VFR_RETURN_INVALID_PARAMETER, A->getLine(), "\"-\" can't be used when not in int decimal type. ");
+ }
+ if (_GET_CURRQEST_VARTINFO().mIsBitVar) {
+ MaxU4 = _STOU32(A->getText(), A->getLine());
+ 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");
}
- break;
- case EFI_IFR_TYPE_NUM_SIZE_8 :
- MaxU1 = _STOU8(A->getText());
- if (MaxU1 < MinU1) {
- _PCATCH (VFR_RETURN_INVALID_PARAMETER, A->getLine(), "Maximum can't be less than Minimum");
+ } 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) {
+ 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");
+ }
+ }
+ }
+ 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");
+ }
+ }
+ }
+ 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");
+ }
+ }
+ }
+ 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;
}
- break;
}
>>
{
STEP "=" S:Number ","
<<
- 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;
- case EFI_IFR_TYPE_NUM_SIZE_8 : StepU1 = _STOU8(S->getText()); 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;
- UINT32 DataTypeSize;
+ 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
- _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");
+ 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) {
+ 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]
+ 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 {
+ //
+ // Question stored in bit fields saved as UINT32 type, so the ShrinkSize same as EFI_IFR_TYPE_NUM_SIZE_32.
+ //
+ ShrinkSize = 12;
+ }
+ 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); >>
+ E:EndNumeric <<
+ 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();
+ UINT8 LFlags = _GET_CURRQEST_DATATYPE() & EFI_IFR_NUMERIC_SIZE;
UINT8 HFlags = 0;
+ BOOLEAN IsSetType = FALSE;
+ BOOLEAN IsDisplaySpecified = FALSE;
+ EFI_VFR_VARSTORE_TYPE VarStoreType = gCVfrDataStorage.GetVarStoreType (_GET_CURRQEST_VARTINFO().mVarStoreId);
>>
- numericFlagsField[HFlags, LFlags] ( "\|" numericFlagsField[HFlags, LFlags] )*
- << _PCATCH(NObj.SetFlags (HFlags, LFlags), LineNum); >>
+ numericFlagsField[HFlags, LFlags, IsSetType, IsDisplaySpecified, LineNum] ( "\|" numericFlagsField[HFlags, LFlags, IsSetType, IsDisplaySpecified, LineNum] )*
+ <<
+ //check data type flag
+ 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 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);
+ }
+ >>
;
-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; >>
+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" << 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
- _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");
+ 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) {
+ 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]
}
+ <<
+ 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 {
+ //
+ // Question stored in bit fields saved as UINT32 type, so the ShrinkSize same as EFI_IFR_TYPE_NUM_SIZE_32.
+ //
+ ShrinkSize = 12;
+ }
+ 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); >>
+ E:EndOneOf <<
+ 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();
+ UINT8 LFlags = _GET_CURRQEST_DATATYPE() & EFI_IFR_NUMERIC_SIZE;
UINT8 HFlags = 0;
+ BOOLEAN IsSetType = FALSE;
+ BOOLEAN IsDisplaySpecified = FALSE;
+ EFI_VFR_VARSTORE_TYPE VarStoreType = gCVfrDataStorage.GetVarStoreType (_GET_CURRQEST_VARTINFO().mVarStoreId);
>>
- numericFlagsField[HFlags, LFlags] ( "\|" numericFlagsField[HFlags, LFlags] )*
- << _PCATCH(OObj.SetFlags (HFlags, LFlags), LineNum); >>
+ numericFlagsField[HFlags, LFlags, IsSetType, IsDisplaySpecified, LineNum] ( "\|" numericFlagsField[HFlags, LFlags, IsSetType, IsDisplaySpecified, LineNum] )*
+ <<
+ //check data type flag
+ 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 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);
+ }
+ >>
;
vfrStatementStringType :
@@ -1847,17 +3207,39 @@ vfrStatementStringType :
vfrStatementString :
<<
CIfrString SObj;
+ UINT32 VarArraySize;
+ UINT8 StringMinSize;
+ UINT8 StringMaxSize;
>>
- L:String << SObj.SetLineNo(L->getLine()); >>
+ L:String << SObj.SetLineNo(L->getLine()); gIsStringOp = TRUE;>>
vfrQuestionHeader[SObj] ","
{ F:FLAGS "=" vfrStringFlagsField[SObj, F->getLine()] "," }
{
Key "=" KN:Number "," << AssignQuestionKey (SObj, KN); >>
}
- MinSize "=" MIN:Number "," << SObj.SetMinSize (_STOU8(MIN->getText())); >>
- MaxSize "=" MAX:Number "," << SObj.SetMaxSize (_STOU8(MAX->getText())); >>
+ MinSize "=" MIN:Number "," <<
+ VarArraySize = _GET_CURRQEST_ARRAY_SIZE();
+ StringMinSize = _STOU8(MIN->getText(), MIN->getLine());
+ if (_STOU64(MIN->getText(), MIN->getLine()) > StringMinSize) {
+ _PCATCH (VFR_RETURN_INVALID_PARAMETER, MIN->getLine(), "String MinSize takes only one byte, which can't be larger than 0xFF.");
+ } else if (VarArraySize != 0 && StringMinSize > VarArraySize) {
+ _PCATCH (VFR_RETURN_INVALID_PARAMETER, MIN->getLine(), "String MinSize can't be larger than the max number of elements in string array.");
+ }
+ SObj.SetMinSize (StringMinSize);
+ >>
+ MaxSize "=" MAX:Number "," <<
+ StringMaxSize = _STOU8(MAX->getText(), MAX->getLine());
+ if (_STOU64(MAX->getText(), MAX->getLine()) > StringMaxSize) {
+ _PCATCH (VFR_RETURN_INVALID_PARAMETER, MAX->getLine(), "String MaxSize takes only one byte, which can't be larger than 0xFF.");
+ } else if (VarArraySize != 0 && StringMaxSize > VarArraySize) {
+ _PCATCH (VFR_RETURN_INVALID_PARAMETER, MAX->getLine(), "String MaxSize can't be larger than the max number of elements in string array.");
+ } else if (StringMaxSize < StringMinSize) {
+ _PCATCH (VFR_RETURN_INVALID_PARAMETER, MAX->getLine(), "String MaxSize can't be less than String MinSize.");
+ }
+ SObj.SetMaxSize (StringMaxSize);
+ >>
vfrStatementQuestionOptionList
- E:EndString << CRT_END_OP (E); >>
+ E:EndString << CRT_END_OP (E); gIsStringOp = FALSE;>>
";"
;
@@ -1871,7 +3253,7 @@ vfrStringFlagsField [CIfrString & SObj, UINT32 LineNum] :
;
stringFlagsField [UINT8 & HFlags, UINT8 & LFlags] :
- N:Number << _PCATCH(_STOU8(N->getText()) == 0 ? VFR_RETURN_SUCCESS : VFR_RETURN_UNSUPPORTED, N->getLine()); >>
+ N:Number << _PCATCH(_STOU8(N->getText(), N->getLine()) == 0 ? VFR_RETURN_SUCCESS : VFR_RETURN_UNSUPPORTED, N->getLine()); >>
| "MULTI_LINE" << $LFlags = 0x01; >>
| questionheaderFlagsField[HFlags]
;
@@ -1879,6 +3261,9 @@ stringFlagsField [UINT8 & HFlags, UINT8 & LFlags] :
vfrStatementPassword :
<<
CIfrPassword PObj;
+ UINT32 VarArraySize;
+ UINT16 PasswordMinSize;
+ UINT16 PasswordMaxSize;
>>
L:Password << PObj.SetLineNo(L->getLine()); >>
vfrQuestionHeader[PObj] ","
@@ -1886,8 +3271,27 @@ vfrStatementPassword :
{
Key "=" KN:Number "," << AssignQuestionKey (PObj, KN); >>
}
- MinSize "=" MIN:Number "," << PObj.SetMinSize (_STOU16(MIN->getText())); >>
- MaxSize "=" MAX:Number "," << PObj.SetMaxSize (_STOU16(MAX->getText())); >>
+ MinSize "=" MIN:Number "," <<
+ VarArraySize = _GET_CURRQEST_ARRAY_SIZE();
+ PasswordMinSize = _STOU16(MIN->getText(), MIN->getLine());
+ if (_STOU64(MIN->getText(), MIN->getLine()) > PasswordMinSize) {
+ _PCATCH (VFR_RETURN_INVALID_PARAMETER, MIN->getLine(), "Password MinSize takes only two byte, which can't be larger than 0xFFFF.");
+ } else if (VarArraySize != 0 && PasswordMinSize > VarArraySize) {
+ _PCATCH (VFR_RETURN_INVALID_PARAMETER, MIN->getLine(), "Password MinSize can't be larger than the max number of elements in password array.");
+ }
+ PObj.SetMinSize (PasswordMinSize);
+ >>
+ MaxSize "=" MAX:Number "," <<
+ PasswordMaxSize = _STOU16(MAX->getText(), MAX->getLine());
+ if (_STOU64(MAX->getText(), MAX->getLine()) > PasswordMaxSize) {
+ _PCATCH (VFR_RETURN_INVALID_PARAMETER, MAX->getLine(), "Password MaxSize takes only two byte, which can't be larger than 0xFFFF.");
+ } else if (VarArraySize != 0 && PasswordMaxSize > VarArraySize) {
+ _PCATCH (VFR_RETURN_INVALID_PARAMETER, MAX->getLine(), "Password MaxSize can't be larger than the max number of elements in password array.");
+ } else if (PasswordMaxSize < PasswordMinSize) {
+ _PCATCH (VFR_RETURN_INVALID_PARAMETER, MAX->getLine(), "Password MaxSize can't be less than Password MinSize.");
+ }
+ PObj.SetMaxSize (PasswordMaxSize);
+ >>
{ Encoding "=" Number "," }
vfrStatementQuestionOptionList
E:EndPassword << CRT_END_OP (E); >>
@@ -1901,23 +3305,34 @@ vfrPasswordFlagsField [CIfrPassword & PObj, UINT32 LineNum] :
;
passwordFlagsField [UINT8 & HFlags] :
- N:Number << _PCATCH(_STOU8(N->getText()) == 0 ? VFR_RETURN_SUCCESS : VFR_RETURN_UNSUPPORTED, N->getLine()); >>
+ N:Number << _PCATCH(_STOU8(N->getText(), N->getLine()) == 0 ? VFR_RETURN_SUCCESS : VFR_RETURN_UNSUPPORTED, N->getLine()); >>
| questionheaderFlagsField[HFlags]
;
vfrStatementOrderedList :
<<
CIfrOrderedList OLObj;
+ UINT32 VarArraySize;
>>
- L:OrderedList << OLObj.SetLineNo(L->getLine()); >>
+ L:OrderedList << OLObj.SetLineNo(L->getLine()); gIsOrderedList = TRUE;>>
vfrQuestionHeader[OLObj] ","
- << OLObj.SetMaxContainers ((UINT8)_GET_CURRQEST_VARSIZE()); >>
+ <<
+ VarArraySize = _GET_CURRQEST_ARRAY_SIZE();
+ OLObj.SetMaxContainers ((UINT8) (VarArraySize > 0xFF ? 0xFF : VarArraySize));
+ >>
{
- MaxContainers "=" M:Number "," << OLObj.SetMaxContainers (_STOU8(M->getText())); >>
+ MaxContainers "=" M:Number "," <<
+ if (_STOU64(M->getText(), M->getLine()) > _STOU8(M->getText(), M->getLine())) {
+ _PCATCH (VFR_RETURN_INVALID_PARAMETER, M->getLine(), "OrderedList MaxContainers takes only one byte, which can't be larger than 0xFF.");
+ } else if (VarArraySize != 0 && _STOU8(M->getText(), M->getLine()) > VarArraySize) {
+ _PCATCH (VFR_RETURN_INVALID_PARAMETER, M->getLine(), "OrderedList MaxContainers can't be larger than the max number of elements in array.");
+ }
+ OLObj.SetMaxContainers (_STOU8(M->getText(), M->getLine()));
+ >>
}
- { F:FLAGS "=" vfrOrderedListFlags[OLObj, F->getLine()] }
+ { F:FLAGS "=" vfrOrderedListFlags[OLObj, F->getLine()] {","}}
vfrStatementQuestionOptionList
- E:EndList << CRT_END_OP (E); >>
+ E:EndList << CRT_END_OP (E); gIsOrderedList = FALSE;>>
";"
;
@@ -1931,7 +3346,7 @@ vfrOrderedListFlags [CIfrOrderedList & OLObj, UINT32 LineNum] :
;
orderedlistFlagsField [UINT8 & HFlags, UINT8 & LFlags] :
- N:Number << _PCATCH(_STOU8(N->getText()) == 0 ? VFR_RETURN_SUCCESS : VFR_RETURN_UNSUPPORTED, N->getLine()); >>
+ N:Number << _PCATCH(_STOU8(N->getText(), N->getLine()) == 0 ? VFR_RETURN_SUCCESS : VFR_RETURN_UNSUPPORTED, N->getLine()); >>
| "UNIQUE" << $LFlags |= 0x01; >>
| "NOEMPTY" << $LFlags |= 0x02; >>
| questionheaderFlagsField[HFlags]
@@ -1943,13 +3358,18 @@ vfrStatementTime :
CHAR8 *VarIdStr[3] = {NULL, };
CIfrTime TObj;
EFI_IFR_TYPE_VALUE Val = gZeroEfiIfrTypeValue;
+ UINT8 Size = OFFSET_OF (EFI_IFR_DEFAULT, Value) + sizeof (EFI_HII_TIME);
>>
L:Time << TObj.SetLineNo(L->getLine()); >>
(
(
- vfrQuestionHeader[TObj, QUESTION_TIME] ","
+ vfrQuestionHeader[TObj, QUESTION_TIME] "," <<
+ if (_GET_CURRQEST_DATATYPE() == EFI_IFR_TYPE_OTHER) {
+ _GET_CURRQEST_VARTINFO().mVarType = EFI_IFR_TYPE_TIME;
+ }
+ >>
{ F:FLAGS "=" vfrTimeFlags[TObj, F->getLine()] "," }
- vfrStatementDefault
+ vfrStatementQuestionOptionList
)
|
(
@@ -1970,15 +3390,16 @@ vfrStatementTime :
Prompt "=" "STRING_TOKEN" "\(" SP:Number "\)" ","
Help "=" "STRING_TOKEN" "\(" SH:Number "\)" ","
minMaxTimeStepDefault[Val.time, 2]
+ { G:FLAGS "=" vfrTimeFlags[TObj, G->getLine()] "," }
<<
mCVfrQuestionDB.RegisterOldTimeQuestion (VarIdStr[0], VarIdStr[1], VarIdStr[2], QId);
TObj.SetQuestionId (QId);
TObj.SetFlags (EFI_IFR_QUESTION_FLAG_DEFAULT, QF_TIME_STORAGE_TIME);
- TObj.SetPrompt (_STOSID(HP->getText()));
- TObj.SetHelp (_STOSID(HH->getText()));
+ TObj.SetPrompt (_STOSID(HP->getText(), HP->getLine()));
+ TObj.SetHelp (_STOSID(HH->getText(), HH->getLine()));
if (VarIdStr[0] != NULL) { delete VarIdStr[0]; } if (VarIdStr[1] != NULL) { delete VarIdStr[1]; } if (VarIdStr[2] != NULL) { delete VarIdStr[2]; }
>>
- << {CIfrDefault DefaultObj(EFI_HII_DEFAULT_CLASS_STANDARD, EFI_IFR_TYPE_TIME, Val); DefaultObj.SetLineNo(L->getLine());} >>
+ << {CIfrDefault DefaultObj(Size, EFI_HII_DEFAULT_CLASS_STANDARD, EFI_IFR_TYPE_TIME, Val); DefaultObj.SetLineNo(L->getLine());} >>
)
( vfrStatementInconsistentIf )*
)
@@ -1994,19 +3415,19 @@ minMaxTimeStepDefault[EFI_HII_TIME & T, UINT8 KeyValue] :
"default" "=" N:Number "," <<
switch (KeyValue) {
case 0:
- T.Hour = _STOU8(N->getText());
+ T.Hour = _STOU8(N->getText(), N->getLine());
if (T.Hour > 23) {
_PCATCH (VFR_RETURN_INVALID_PARAMETER, N->getLine(), "Hour default value must be between 0 and 23.");
}
break;
case 1:
- T.Minute = _STOU8(N->getText());
+ T.Minute = _STOU8(N->getText(), N->getLine());
if (T.Minute > 59) {
_PCATCH (VFR_RETURN_INVALID_PARAMETER, N->getLine(), "Minute default value must be between 0 and 59.");
}
break;
case 2:
- T.Second = _STOU8(N->getText());
+ T.Second = _STOU8(N->getText(), N->getLine());
if (T.Second > 59) {
_PCATCH (VFR_RETURN_INVALID_PARAMETER, N->getLine(), "Second default value must be between 0 and 59.");
}
@@ -2023,7 +3444,7 @@ vfrTimeFlags [CIfrTime & TObj, UINT32 LineNum] :
;
timeFlagsField [UINT8 & Flags] :
- N:Number << $Flags |= _STOU8(N->getText()); >>
+ N:Number << $Flags |= _STOU8(N->getText(), N->getLine()); >>
| "HOUR_SUPPRESS" << $Flags |= 0x01; >>
| "MINUTE_SUPPRESS" << $Flags |= 0x02; >>
| "SECOND_SUPPRESS" << $Flags |= 0x04; >>
@@ -2038,7 +3459,10 @@ vfrStatementQuestionTag :
vfrStatementNoSubmitIf |
vfrStatementDisableIfQuest |
vfrStatementRefresh |
- vfrStatementVarstoreDevice
+ vfrStatementVarstoreDevice |
+ vfrStatementExtension |
+ vfrStatementRefreshEvent "," |
+ vfrStatementWarningIf
;
vfrStatementQuestionTagList :
@@ -2050,6 +3474,8 @@ vfrStatementQuestionOptionTag :
vfrStatementGrayOutIfQuest |
vfrStatementValue |
vfrStatementDefault |
+ vfrStatementRead |
+ vfrStatementWrite |
vfrStatementOptions
;
@@ -2065,6 +3491,7 @@ vfrStatementStatList :
vfrStatementQuestions |
vfrStatementConditionalNew |
vfrStatementLabel |
+ vfrStatementExtension |
// Just for framework vfr compatibility
vfrStatementInvalid
;
@@ -2080,10 +3507,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); >>
";"
@@ -2097,7 +3523,7 @@ vfrStatementInconsistentIfStat :
}
IIObj.SetLineNo(L->getLine());
>>
- Prompt "=" "STRING_TOKEN" "\(" S:Number "\)" "," << IIObj.SetError (_STOSID(S->getText())); >>
+ Prompt "=" "STRING_TOKEN" "\(" S:Number "\)" "," << IIObj.SetError (_STOSID(S->getText(), S->getLine())); >>
{ FLAGS "=" flagsField ( "\|" flagsField )* "," }
vfrStatementExpression[0]
E:EndIf << CRT_END_OP (E); >>
@@ -2179,7 +3605,7 @@ vfrStatementGrayOutIfStatOld :
vfrImageTag :
<< CIfrImage IObj; >>
- L:Image "=" "IMAGE_TOKEN" "\(" S1:Number "\)" << IObj.SetImageId (_STOSID(S1->getText())); IObj.SetLineNo(L->getLine()); >>
+ L:Image "=" "IMAGE_TOKEN" "\(" S1:Number "\)" << IObj.SetImageId (_STOSID(S1->getText(), S1->getLine())); IObj.SetLineNo(L->getLine()); >>
;
vfrLockedTag :
@@ -2187,6 +3613,11 @@ vfrLockedTag :
L:Locked << LObj.SetLineNo(L->getLine()); >>
;
+vfrModalTag :
+ << CIfrModal MObj; >>
+ L:Modal << MObj.SetLineNo(L->getLine()); >>
+ ;
+
vfrStatementStatTag :
vfrImageTag |
vfrLockedTag
@@ -2201,6 +3632,11 @@ vfrStatementImage :
";"
;
+vfrStatementModal :
+ vfrModalTag
+ ";"
+ ;
+
vfrStatementLocked :
vfrLockedTag
";"
@@ -2209,42 +3645,59 @@ vfrStatementLocked :
vfrStatementInconsistentIf :
<< CIfrInconsistentIf IIObj; >>
L:InconsistentIf << IIObj.SetLineNo(L->getLine()); >>
- Prompt "=" "STRING_TOKEN" "\(" S:Number "\)" "," << IIObj.SetError (_STOSID(S->getText())); >>
+ Prompt "=" "STRING_TOKEN" "\(" S:Number "\)" "," << IIObj.SetError (_STOSID(S->getText(), S->getLine())); >>
{ FLAGS "=" flagsField ( "\|" flagsField )* "," }
vfrStatementExpression[0]
- E:EndIf << CRT_END_OP (E); >>
+ E:EndIf {";"} << CRT_END_OP (E); >>
;
vfrStatementNoSubmitIf :
<< CIfrNoSubmitIf NSIObj; >>
L:NoSubmitIf << NSIObj.SetLineNo(L->getLine()); >>
- Prompt "=" "STRING_TOKEN" "\(" S:Number "\)" "," << NSIObj.SetError (_STOSID(S->getText())); >>
+ Prompt "=" "STRING_TOKEN" "\(" S:Number "\)" "," << NSIObj.SetError (_STOSID(S->getText(), S->getLine())); >>
{ FLAGS "=" flagsField ( "\|" flagsField )* "," }
vfrStatementExpression[0]
- E:EndIf << CRT_END_OP (E); >>
+ E:EndIf {";"} << CRT_END_OP (E); >>
+ ;
+
+vfrStatementWarningIf :
+ << CIfrWarningIf WIObj; >>
+ L:WarningIf << WIObj.SetLineNo(L->getLine()); >>
+ Prompt "=" "STRING_TOKEN" "\(" S:Number "\)" "," << WIObj.SetWarning (_STOSID(S->getText(), S->getLine())); >>
+ {Timeout "=" T:Number "," << WIObj.SetTimeOut (_STOU8(T->getText(), T->getLine())); >>}
+ vfrStatementExpression[0]
+ E:EndIf {";"} << CRT_END_OP (E); >>
;
vfrStatementDisableIfQuest :
<<
CIfrDisableIf DIObj;
- mConstantOnlyInExpression = TRUE;
>>
L:DisableIf << DIObj.SetLineNo(L->getLine()); >>
- vfrStatementExpression[0] ";" << mConstantOnlyInExpression = FALSE; >>
+ vfrStatementExpression[0] ";"
vfrStatementQuestionOptionList
- E:EndIf << CRT_END_OP (E); >>
+ E:EndIf {";"} << CRT_END_OP (E); >>
;
vfrStatementRefresh :
<< CIfrRefresh RObj; >>
L:Refresh << RObj.SetLineNo(L->getLine()); >>
- Interval "=" I:Number << RObj.SetRefreshInterval (_STOU8(I->getText())); >>
+ Interval "=" I:Number << RObj.SetRefreshInterval (_STOU8(I->getText(), I->getLine())); >>
+ ;
+
+vfrStatementRefreshEvent :
+ <<
+ CIfrRefreshId RiObj;
+ EFI_GUID Guid;
+ >>
+ L:RefreshGuid << RiObj.SetLineNo(L->getLine()); >>
+ "=" guidDefinition[Guid] << RiObj.SetRefreshEventGroutId (&Guid); >>
;
vfrStatementVarstoreDevice :
<< CIfrVarStoreDevice VDObj; >>
L:VarstoreDevice << VDObj.SetLineNo(L->getLine()); >>
- "=" "STRING_TOKEN" "\(" S:Number "\)" "," << VDObj.SetDevicePath (_STOSID(S->getText())); >>
+ "=" "STRING_TOKEN" "\(" S:Number "\)" "," << VDObj.SetDevicePath (_STOSID(S->getText(), S->getLine())); >>
;
vfrStatementSuppressIfQuest :
@@ -2253,7 +3706,7 @@ vfrStatementSuppressIfQuest :
{ FLAGS "=" flagsField ( "\|" flagsField )* "," }
vfrStatementExpression[0] ";"
vfrStatementQuestionOptionList
- E:EndIf << CRT_END_OP (E); >>
+ E:EndIf {";"} << CRT_END_OP (E); >>
;
vfrStatementGrayOutIfQuest :
@@ -2262,7 +3715,7 @@ vfrStatementGrayOutIfQuest :
{ FLAGS "=" flagsField ( "\|" flagsField )* "," }
vfrStatementExpression[0] ";"
vfrStatementQuestionOptionList
- E:EndIf << CRT_END_OP (E); >>
+ E:EndIf {";"} << CRT_END_OP (E); >>
;
vfrStatementOptions :
@@ -2271,33 +3724,153 @@ vfrStatementOptions :
vfrStatementOneOfOption :
<<
- EFI_IFR_TYPE_VALUE Val = gZeroEfiIfrTypeValue;
- CIfrOneOfOption OOOObj;
+ UINT8 ValueList[EFI_IFR_MAX_LENGTH] = {0,};
+ EFI_IFR_TYPE_VALUE *Val = (EFI_IFR_TYPE_VALUE *) ValueList;
CHAR8 *VarStoreName = NULL;
+ UINT32 Size = 0;
+ BOOLEAN TypeError = FALSE;
+ EFI_VFR_RETURN_CODE ReturnCode = VFR_RETURN_SUCCESS;
+ EFI_GUID *VarStoreGuid = NULL;
+ BOOLEAN ArrayType = FALSE;
+ CIfrOneOfOption *OOOObj;
+ UINT8 *Type8 = (UINT8 *) ValueList;
+ UINT16 *Type16 = (UINT16 *) ValueList;
+ UINT32 *Type32 = (UINT32 *) ValueList;
+ UINT64 *Type64 = (UINT64 *) ValueList;
>>
- 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); >>
- F:FLAGS "=" vfrOneOfOptionFlags[OOOObj, F->getLine()]
+ L:Option <<
+ if (_GET_CURRQEST_DATATYPE() == EFI_IFR_TYPE_OTHER) {
+ _PCATCH (VFR_RETURN_FATAL_ERROR, L->getLine(), "Get data type error.");
+ }
+
+ >>
+ 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(), _GET_CURRQEST_VARTINFO().mIsBitVar);
+ if (_GET_CURRQEST_VARTINFO().mIsBitVar) {
+ gCurrentMinMaxData->SetMinMaxStepData(Val->u32, Val->u32, (UINT32) Step);
+ } else {
+ switch (_GET_CURRQEST_DATATYPE()) {
+ case EFI_IFR_TYPE_NUM_SIZE_64:
+ gCurrentMinMaxData->SetMinMaxStepData(Val->u64, Val->u64, Step);
+ break;
+ case EFI_IFR_TYPE_NUM_SIZE_32:
+ 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) {
+ switch (_GET_CURRQEST_DATATYPE()) {
+ case EFI_IFR_TYPE_NUM_SIZE_8 :
+ while (Type8[Size] != 0) {
+ Size++;
+ }
+ break;
+ case EFI_IFR_TYPE_NUM_SIZE_16 :
+ while (Type16[Size] != 0) {
+ Size++;
+ }
+ Size *= sizeof (UINT16);
+ break;
+ case EFI_IFR_TYPE_NUM_SIZE_32 :
+ while (Type32[Size] != 0) {
+ Size++;
+ }
+ Size *= sizeof (UINT32);
+ break;
+ case EFI_IFR_TYPE_NUM_SIZE_64 :
+ while (Type64[Size] != 0) {
+ Size++;
+ }
+ Size *= sizeof (UINT64);
+ break;
+ default:
+ break;
+ }
+ } else {
+ //
+ // 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);
+ } else {
+ if (_GET_CURRQEST_VARTINFO().mIsBitVar) {
+ OOOObj->SetType ( EFI_IFR_TYPE_NUM_SIZE_32);
+ } else {
+ OOOObj->SetType (_GET_CURRQEST_DATATYPE());
+ }
+ }
+ OOOObj->SetValue (*Val);
+ >>
+ F:FLAGS "=" vfrOneOfOptionFlags[*OOOObj, F->getLine()]
<<
- _PCATCH(mCVfrDataStorage.GetVarStoreName (_GET_CURRQEST_VARTINFO().mVarStoreId, &VarStoreName), L->getLine());
- if (OOOObj.GetFlags () & 0x10) {
- _PCATCH(mCVfrDefaultStore.BufferVarStoreAltConfigAdd (
- EFI_HII_DEFAULT_CLASS_STANDARD,
- _GET_CURRQEST_VARTINFO(),
- VarStoreName,
- _GET_CURRQEST_DATATYPE (),
- Val
- ), L->getLine());
- }
- if (OOOObj.GetFlags () & 0x20) {
- _PCATCH(mCVfrDefaultStore.BufferVarStoreAltConfigAdd (
- EFI_HII_DEFAULT_CLASS_MANUFACTURING,
- _GET_CURRQEST_VARTINFO(),
- VarStoreName,
- _GET_CURRQEST_DATATYPE (),
- Val
- ), L->getLine());
+ //
+ // Array type only for default type OneOfOption.
+ //
+ if ((OOOObj->GetFlags () & (EFI_IFR_OPTION_DEFAULT | EFI_IFR_OPTION_DEFAULT_MFG)) == 0 && ArrayType) {
+ _PCATCH (VFR_RETURN_FATAL_ERROR, L->getLine(), "Default keyword should with array value type!");
+ }
+
+ //
+ // Clear the default flag if the option not use array value but has default flag.
+ //
+ if ((OOOObj->GetFlags () & (EFI_IFR_OPTION_DEFAULT | EFI_IFR_OPTION_DEFAULT_MFG)) != 0 && !ArrayType && gIsOrderedList) {
+ OOOObj->SetFlags(OOOObj->GetFlags () & ~(EFI_IFR_OPTION_DEFAULT | EFI_IFR_OPTION_DEFAULT_MFG));
+ }
+
+ if (_GET_CURRQEST_VARTINFO().mVarStoreId != EFI_VARSTORE_ID_INVALID) {
+ _PCATCH(gCVfrDataStorage.GetVarStoreName (_GET_CURRQEST_VARTINFO().mVarStoreId, &VarStoreName), L->getLine());
+ VarStoreGuid = gCVfrDataStorage.GetVarStoreGuid(_GET_CURRQEST_VARTINFO().mVarStoreId);
+ if (OOOObj->GetFlags () & EFI_IFR_OPTION_DEFAULT) {
+ CheckDuplicateDefaultValue (EFI_HII_DEFAULT_CLASS_STANDARD, F);
+ _PCATCH(gCVfrDefaultStore.BufferVarStoreAltConfigAdd (
+ EFI_HII_DEFAULT_CLASS_STANDARD,
+ _GET_CURRQEST_VARTINFO(),
+ VarStoreName,
+ VarStoreGuid,
+ _GET_CURRQEST_DATATYPE (),
+ *Val
+ ), L->getLine());
+ }
+ if (OOOObj->GetFlags () & EFI_IFR_OPTION_DEFAULT_MFG) {
+ CheckDuplicateDefaultValue (EFI_HII_DEFAULT_CLASS_MANUFACTURING, F);
+ _PCATCH(gCVfrDefaultStore.BufferVarStoreAltConfigAdd (
+ EFI_HII_DEFAULT_CLASS_MANUFACTURING,
+ _GET_CURRQEST_VARTINFO(),
+ VarStoreName,
+ VarStoreGuid,
+ _GET_CURRQEST_DATATYPE (),
+ *Val
+ ), L->getLine());
+ }
}
>>
{
@@ -2310,16 +3883,16 @@ vfrStatementOneOfOption :
//
CIfrOptionKey IfrOptionKey (
gCurrentQuestion->QUESTION_ID(),
- Val,
- _STOQID(KN->getText())
+ *Val,
+ _STOQID(KN->getText(), KN->getLine())
);
SET_LINE_INFO (IfrOptionKey, KN);
>>
}
(
- T:"," vfrImageTag << OOOObj.SetScope (1); CRT_END_OP (T); >>
+ T:"," vfrImageTag << OOOObj->SetScope (1); CRT_END_OP (T); >>
)*
- ";"
+ ";" << if (OOOObj != NULL) {delete OOOObj;} >>
;
vfrOneOfOptionFlags [CIfrOneOfOption & OOOObj, UINT32 LineNum] :
@@ -2333,15 +3906,36 @@ vfrOneOfOptionFlags [CIfrOneOfOption & OOOObj, UINT32 LineNum] :
;
oneofoptionFlagsField [UINT8 & HFlags, UINT8 & LFlags] :
- N:Number << $LFlags |= _STOU8(N->getText()); >>
+ N:Number << $LFlags |= _STOU8(N->getText(), N->getLine()); >>
| "OPTION_DEFAULT" << $LFlags |= 0x10; >>
| "OPTION_DEFAULT_MFG" << $LFlags |= 0x20; >>
| InteractiveFlag << $HFlags |= 0x04; >>
- | NVAccessFlag << $HFlags |= 0x08; >>
| ResetRequiredFlag << $HFlags |= 0x10; >>
- | LateCheckFlag << $HFlags |= 0x20; >>
+ | ReconnectRequiredFlag << $HFlags |= 0x40; >>
| ManufacturingFlag << $LFlags |= 0x20; >>
| DefaultFlag << $LFlags |= 0x10; >>
+ | A:NVAccessFlag <<
+ if (mCompatibleMode) {
+ $HFlags |= 0x08;
+ } else {
+ gCVfrErrorHandle.HandleWarning (
+ VFR_WARNING_OBSOLETED_FRAMEWORK_OPCODE,
+ A->getLine(),
+ A->getText()
+ );
+ }
+ >>
+ | L:LateCheckFlag <<
+ if (mCompatibleMode) {
+ $HFlags |= 0x20;
+ } else {
+ gCVfrErrorHandle.HandleWarning (
+ VFR_WARNING_OBSOLETED_FRAMEWORK_OPCODE,
+ L->getLine(),
+ L->getText()
+ );
+ }
+ >>
;
vfrStatementLabel :
@@ -2359,7 +3953,7 @@ vfrStatementLabel :
{
CIfrLabel LObj2;
LObj2.SetLineNo(L->getLine());
- LObj2.SetNumber (_STOU16(N->getText()));
+ LObj2.SetNumber (_STOU16(N->getText(), N->getLine()));
}
>>
";"
@@ -2368,10 +3962,10 @@ vfrStatementLabel :
vfrStatementBanner :
<< CIfrBanner BObj; >>
B:Banner { "," } << BObj.SetLineNo(B->getLine()); >>
- Title "=" "STRING_TOKEN" "\(" S:Number "\)" "," << BObj.SetTitle (_STOSID(S->getText())); >>
+ Title "=" "STRING_TOKEN" "\(" S:Number "\)" "," << BObj.SetTitle (_STOSID(S->getText(), S->getLine())); >>
(
(
- Line L:Number "," << BObj.SetLine (_STOU16(L->getText())); >>
+ Line L:Number "," << BObj.SetLine (_STOU16(L->getText(), L->getLine())); >>
Align
(
Left << BObj.SetAlign (0); >>
@@ -2381,7 +3975,7 @@ vfrStatementBanner :
)
|
(
- Timeout "=" T:Number ";" << {CIfrTimeout TObj(_STOU16(T->getText()));} >>
+ Timeout "=" T:Number ";" << {CIfrTimeout TObj(_STOU16(T->getText(), T->getLine()));} >>
)
)
;
@@ -2460,6 +4054,8 @@ vfrStatementInvalidSaveRestoreDefaults :
#token RuleRef("ruleref") "ruleref"
#token StringRef("stringref") "stringref"
#token PushThis("pushthis") "pushthis"
+#token Security("security") "security"
+#token Get("get") "get"
#token True("TRUE") "TRUE"
#token False("FALSE") "FALSE"
#token One("ONE") "ONE"
@@ -2471,6 +4067,7 @@ vfrStatementInvalidSaveRestoreDefaults :
#token AND("AND") "AND"
#token OR("OR") "OR"
#token NOT("NOT") "NOT"
+#token Set("set") "set"
#token BitWiseNot("~") "\~"
#token BoolVal("boolval") "boolval"
#token StringVal("stringval") "stringval"
@@ -2478,15 +4075,18 @@ vfrStatementInvalidSaveRestoreDefaults :
#token ToUpper("toupper") "toupper"
#token ToLower("tolower") "tolower"
#token Match("match") "match"
+#token Match2("match2") "match2"
#token Catenate("catenate") "catenate"
#token QuestionRefVal("questionrefval") "questionrefval"
#token StringRefVal("stringrefval") "stringrefval"
+#token Map("map") "map"
+#token RefreshGuid("refreshguid") "refreshguid"
//
// Root expression extension function called by other function.
//
vfrStatementExpression [UINT32 RootLevel, UINT32 ExpOpCount = 0] :
- << if ($RootLevel == 0) {_CLEAR_SAVED_OPHDR ();} >>
+ << if ($RootLevel == 0) {mCIfrOpHdrIndex ++; if (mCIfrOpHdrIndex >= MAX_IFR_EXPRESSION_DEPTH) _PCATCH (VFR_RETURN_INVALID_PARAMETER, 0, "The depth of expression exceeds the max supported level 8!"); _CLEAR_SAVED_OPHDR ();} >>
andTerm[$RootLevel, $ExpOpCount]
(
L:OR andTerm[$RootLevel, $ExpOpCount] << $ExpOpCount++; CIfrOr OObj(L->getLine()); >>
@@ -2498,11 +4098,15 @@ vfrStatementExpression [UINT32 RootLevel, UINT32 ExpOpCount = 0] :
if ($ExpOpCount > 1 && $RootLevel == 0) {
if (_SET_SAVED_OPHDR_SCOPE()) {
CIfrEnd EObj;
- if (mCIfrOpHdrLineNo != 0) {
- EObj.SetLineNo (mCIfrOpHdrLineNo);
+ if (mCIfrOpHdrLineNo[mCIfrOpHdrIndex] != 0) {
+ EObj.SetLineNo (mCIfrOpHdrLineNo[mCIfrOpHdrIndex]);
}
}
}
+
+ if ($RootLevel == 0) {
+ mCIfrOpHdrIndex --;
+ }
>>
;
@@ -2640,11 +4244,13 @@ castTerm [UINT32 & RootLevel, UINT32 & ExpOpCount]:
atomTerm [UINT32 & RootLevel, UINT32 & ExpOpCount]:
vfrExpressionCatenate[$RootLevel, $ExpOpCount]
| vfrExpressionMatch[$RootLevel, $ExpOpCount]
+ | vfrExpressionMatch2[$RootLevel, $ExpOpCount]
| vfrExpressionParen[$RootLevel, $ExpOpCount]
| vfrExpressionBuildInFunction[$RootLevel, $ExpOpCount]
| vfrExpressionConstant[$RootLevel, $ExpOpCount]
| vfrExpressionUnaryOp[$RootLevel, $ExpOpCount]
| vfrExpressionTernaryOp[$RootLevel, $ExpOpCount]
+ | vfrExpressionMap[$RootLevel, $ExpOpCount]
| (
L:NOT
atomTerm[$RootLevel, $ExpOpCount] << { CIfrNot NObj(L->getLine()); $ExpOpCount++; } >>
@@ -2669,6 +4275,20 @@ vfrExpressionMatch [UINT32 & RootLevel, UINT32 & ExpOpCount]:
"\)" << { CIfrMatch MObj(L->getLine()); $ExpOpCount++; } >>
;
+vfrExpressionMatch2 [UINT32 & RootLevel, UINT32 & ExpOpCount]:
+ <<
+ EFI_GUID Guid;
+ >>
+ L:Match2
+ "\("
+ vfrStatementExpressionSub[$RootLevel + 1, $ExpOpCount]
+ ","
+ vfrStatementExpressionSub[$RootLevel + 1, $ExpOpCount]
+ ","
+ guidDefinition[Guid]
+ "\)" << { CIfrMatch2 M2Obj(L->getLine(), &Guid); $ExpOpCount++; } >>
+ ;
+
vfrExpressionParen [UINT32 & RootLevel, UINT32 & ExpOpCount]:
"\("
vfrStatementExpressionSub[$RootLevel + 1, $ExpOpCount]
@@ -2681,10 +4301,12 @@ vfrExpressionBuildInFunction [UINT32 & RootLevel, UINT32 & ExpOpCount] :
| ideqvalExp[$RootLevel, $ExpOpCount]
| ideqidExp[$RootLevel, $ExpOpCount]
| ideqvallistExp[$RootLevel, $ExpOpCount]
- | questionref13Exp[$RootLevel, $ExpOpCount]
+ | questionref1Exp[$RootLevel, $ExpOpCount]
| rulerefExp[$RootLevel, $ExpOpCount]
| stringref1Exp[$RootLevel, $ExpOpCount]
| pushthisExp[$RootLevel, $ExpOpCount]
+ | securityExp[$RootLevel, $ExpOpCount]
+ | getExp[$RootLevel, $ExpOpCount]
;
dupExp [UINT32 & RootLevel, UINT32 & ExpOpCount] :
@@ -2698,8 +4320,8 @@ vareqvalExp [UINT32 & RootLevel, UINT32 & ExpOpCount] :
UINT16 ConstVal;
CHAR8 *VarIdStr;
UINT32 LineNo;
- EFI_VFR_VARSTORE_TYPE VarStoreType = EFI_VFR_VARSTORE_INVALID;
EFI_VFR_RETURN_CODE VfrReturnCode = VFR_RETURN_SUCCESS;
+ EFI_VARSTORE_ID VarStoreId = EFI_VARSTORE_ID_INVALID;
>>
L:VarEqVal <<
if (!mCompatibleMode) {
@@ -2710,12 +4332,12 @@ vareqvalExp [UINT32 & RootLevel, UINT32 & ExpOpCount] :
OpenParen
VN:Number <<
VarIdStr = NULL; _STRCAT(&VarIdStr, VK->getText()); _STRCAT(&VarIdStr, VN->getText());
- VfrReturnCode = mCVfrDataStorage.GetVarStoreType (VarIdStr, VarStoreType);
+ VfrReturnCode = gCVfrDataStorage.GetVarStoreId (VarIdStr, &VarStoreId);
if (VfrReturnCode == VFR_RETURN_UNDEFINED) {
- _PCATCH (mCVfrDataStorage.DeclareEfiVarStore (
+ _PCATCH (gCVfrDataStorage.DeclareEfiVarStore (
VarIdStr,
&mFormsetGuid,
- _STOSID(VN->getText()),
+ _STOSID(VN->getText(), VN->getLine()),
0x2, //default type is UINT16
FALSE
), VN);
@@ -2729,7 +4351,7 @@ vareqvalExp [UINT32 & RootLevel, UINT32 & ExpOpCount] :
(
(
"=="
- V1:Number << ConstVal = _STOU16(V1->getText()); >>
+ V1:Number << ConstVal = _STOU16(V1->getText(), V1->getLine()); >>
<<
if (Mask == 0) {
CIfrEqIdVal EIVObj (L->getLine());
@@ -2745,25 +4367,25 @@ vareqvalExp [UINT32 & RootLevel, UINT32 & ExpOpCount] :
|
(
"<="
- V2:Number << ConstVal = _STOU16(V2->getText()); >>
+ V2:Number << ConstVal = _STOU16(V2->getText(), V2->getLine()); >>
<< IdEqValDoSpecial ($ExpOpCount, L->getLine(), QId, VarIdStr, Mask, ConstVal, LESS_EQUAL); >>
)
|
(
"<"
- V3:Number << ConstVal = _STOU16(V3->getText()); >>
+ V3:Number << ConstVal = _STOU16(V3->getText(), V3->getLine()); >>
<< IdEqValDoSpecial ($ExpOpCount, L->getLine(), QId, VarIdStr, Mask, ConstVal, LESS_THAN); >>
)
|
(
">="
- V4:Number << ConstVal = _STOU16(V4->getText()); >>
+ V4:Number << ConstVal = _STOU16(V4->getText(), V4->getLine()); >>
<< IdEqValDoSpecial ($ExpOpCount, L->getLine(), QId, VarIdStr, Mask, ConstVal, GREATER_EQUAL); >>
)
|
(
">"
- V5:Number << ConstVal = _STOU16(V5->getText()); >>
+ V5:Number << ConstVal = _STOU16(V5->getText(), V5->getLine()); >>
<< IdEqValDoSpecial ($ExpOpCount, L->getLine(), QId, VarIdStr, Mask, ConstVal, GREATER_THAN); >>
)
)
@@ -2782,7 +4404,7 @@ ideqvalExp [UINT32 & RootLevel, UINT32 & ExpOpCount] :
(
(
"=="
- V1:Number << ConstVal = _STOU16(V1->getText()); >>
+ V1:Number << ConstVal = _STOU16(V1->getText(), V1->getLine()); >>
<<
if (Mask == 0) {
CIfrEqIdVal EIVObj (L->getLine());
@@ -2798,25 +4420,25 @@ ideqvalExp [UINT32 & RootLevel, UINT32 & ExpOpCount] :
|
(
"<="
- V2:Number << ConstVal = _STOU16(V2->getText()); >>
+ V2:Number << ConstVal = _STOU16(V2->getText(), V2->getLine()); >>
<< IdEqValDoSpecial ($ExpOpCount, L->getLine(), QId, VarIdStr, Mask, ConstVal, LESS_EQUAL); >>
)
|
(
"<"
- V3:Number << ConstVal = _STOU16(V3->getText()); >>
+ V3:Number << ConstVal = _STOU16(V3->getText(), V3->getLine()); >>
<< IdEqValDoSpecial ($ExpOpCount, L->getLine(), QId, VarIdStr, Mask, ConstVal, LESS_THAN); >>
)
|
(
">="
- V4:Number << ConstVal = _STOU16(V4->getText()); >>
+ V4:Number << ConstVal = _STOU16(V4->getText(), V4->getLine()); >>
<< IdEqValDoSpecial ($ExpOpCount, L->getLine(), QId, VarIdStr, Mask, ConstVal, GREATER_EQUAL); >>
)
|
(
">"
- V5:Number << ConstVal = _STOU16(V5->getText()); >>
+ V5:Number << ConstVal = _STOU16(V5->getText(), V5->getLine()); >>
<< IdEqValDoSpecial ($ExpOpCount, L->getLine(), QId, VarIdStr, Mask, ConstVal, GREATER_THAN); >>
)
)
@@ -2887,7 +4509,7 @@ ideqvallistExp[UINT32 & RootLevel, UINT32 & ExpOpCount] :
vfrQuestionDataFieldName[QId, Mask, VarIdStr, LineNo]
"=="
(
- V:Number << ValueList[ListLen] = _STOU16(V->getText()); ListLen++; >>
+ V:Number << ValueList[ListLen] = _STOU16(V->getText(), V->getLine()); ListLen++; >>
)+
<<
if (Mask != 0) {
@@ -2914,50 +4536,26 @@ ideqvallistExp[UINT32 & RootLevel, UINT32 & ExpOpCount] :
>>
;
-questionref13Exp[UINT32 & RootLevel, UINT32 & ExpOpCount] :
+questionref1Exp[UINT32 & RootLevel, UINT32 & ExpOpCount] :
<<
- UINT8 Type = 0x1;
- EFI_STRING_ID DevPath;
- EFI_GUID Guid;
EFI_QUESTION_ID QId = EFI_QUESTION_ID_INVALID;
UINT32 BitMask;
CHAR8 *QName = NULL;
UINT32 LineNo = 0;
>>
L:QuestionRef
- (
- (
- << Type = 0x3; >>
- {
- Path "=" "STRING_TOKEN" "\(" S:Number "\)" << Type = 0x4; DevPath = _STOSID(S->getText()); >>
- }
- {
- Uuid "=" guidDefinition[Guid] << Type = 0x5; >>
- }
- )
- |
- (
- "\("
- (
+ "\("
+ (
QN:StringIdentifier <<
QName = QN->getText();
- LineNo = QN->getLine();
+ LineNo = QN->getLine();
mCVfrQuestionDB.GetQuestionId (QN->getText(), NULL, QId, BitMask);
>>
- | ID:Number << QId = _STOQID(ID->getText()); >>
+ | ID:Number << QId = _STOQID(ID->getText(), ID->getLine()); >>
)
- "\)"
- )
- )
+ "\)"
<<
- switch (Type) {
- case 0x1: {CIfrQuestionRef1 QR1Obj(L->getLine()); _SAVE_OPHDR_COND (QR1Obj, ($ExpOpCount == 0), L->getLine()); QR1Obj.SetQuestionId (QId, QName, LineNo); break;}
- case 0x3: {CIfrQuestionRef3 QR3Obj(L->getLine()); _SAVE_OPHDR_COND (QR3Obj, ($ExpOpCount == 0), L->getLine()); break;}
- case 0x4: {CIfrQuestionRef3_2 QR3_2Obj(L->getLine()); _SAVE_OPHDR_COND (QR3_2Obj, ($ExpOpCount == 0), L->getLine()); QR3_2Obj.SetDevicePath (DevPath); break;}
- case 0x5: {CIfrQuestionRef3_3 QR3_3Obj(L->getLine()); _SAVE_OPHDR_COND (QR3_3Obj, ($ExpOpCount == 0), L->getLine()); QR3_3Obj.SetDevicePath (DevPath); QR3_3Obj.SetGuid (&Guid); break;}
- }
- $ExpOpCount++;
- >>
+ { CIfrQuestionRef1 QR1Obj(L->getLine()); _SAVE_OPHDR_COND (QR1Obj, ($ExpOpCount == 0), L->getLine()); QR1Obj.SetQuestionId (QId, QName, LineNo); } $ExpOpCount++; >>
;
rulerefExp[UINT32 & RootLevel, UINT32 & ExpOpCount] :
@@ -2970,14 +4568,111 @@ rulerefExp[UINT32 & RootLevel, UINT32 & ExpOpCount] :
// stringref (STR_FORM_SET_TITLE)
//
stringref1Exp[UINT32 & RootLevel, UINT32 & ExpOpCount] :
+ <<
+ EFI_STRING_ID RefStringId = EFI_STRING_ID_INVALID;
+ >>
L:StringRef
- "\(" S:Number "\)" << { CIfrStringRef1 SR1Obj(L->getLine()); _SAVE_OPHDR_COND (SR1Obj, ($ExpOpCount == 0), L->getLine()); SR1Obj.SetStringId (_STOSID(S->getText())); $ExpOpCount++; } >>
+ "\("
+ (
+ "STRING_TOKEN"
+ "\("
+ S:Number << RefStringId = _STOSID(S->getText(), S->getLine()); >>
+ "\)"
+ | I:Number << RefStringId = _STOSID(I->getText(), I->getLine()); >>
+ )
+ "\)" << { CIfrStringRef1 SR1Obj(L->getLine()); _SAVE_OPHDR_COND (SR1Obj, ($ExpOpCount == 0), L->getLine()); SR1Obj.SetStringId (RefStringId); $ExpOpCount++; } >>
;
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++; >>
+ ;
+
+numericVarStoreType [UINT8 & VarType] :
+ "NUMERIC_SIZE_1" << $VarType = EFI_IFR_NUMERIC_SIZE_1; >>
+ | "NUMERIC_SIZE_2" << $VarType = EFI_IFR_NUMERIC_SIZE_2; >>
+ | "NUMERIC_SIZE_4" << $VarType = EFI_IFR_NUMERIC_SIZE_4; >>
+ | "NUMERIC_SIZE_8" << $VarType = EFI_IFR_NUMERIC_SIZE_8; >>
+ ;
+
+getExp[UINT32 & RootLevel, UINT32 & ExpOpCount] :
+ <<
+ EFI_VARSTORE_INFO Info;
+ CHAR8 *VarIdStr = NULL;
+ EFI_QUESTION_ID QId = EFI_QUESTION_ID_INVALID;
+ UINT32 Mask = 0;
+ EFI_QUESION_TYPE QType = QUESTION_NORMAL;
+ UINT8 VarType = EFI_IFR_TYPE_UNDEFINED;
+ UINT32 VarSize = 0;
+ Info.mVarStoreId = 0;
+ >>
+ L:Get
+ "\("
+ vfrStorageVarId[Info, VarIdStr, FALSE]
+ {"\|" FLAGS "=" numericVarStoreType [VarType] }
+ "\)" <<
+ {
+ if (Info.mVarStoreId == 0) {
+ // support Date/Time question
+ mCVfrQuestionDB.GetQuestionId (NULL, VarIdStr, QId, Mask, &QType);
+ if (QId == EFI_QUESTION_ID_INVALID || Mask == 0 || QType == QUESTION_NORMAL) {
+ _PCATCH(VFR_RETURN_UNSUPPORTED, L->getLine(), "Get/Set opcode can't get the enough varstore information");
+ }
+ if (QType == QUESTION_DATE) {
+ Info.mVarType = EFI_IFR_TYPE_DATE;
+ } else if (QType == QUESTION_TIME) {
+ Info.mVarType = EFI_IFR_TYPE_TIME;
+ }
+ switch (Mask) {
+ case DATE_YEAR_BITMASK:
+ Info.mInfo.mVarOffset = 0;
+ break;
+ case DATE_DAY_BITMASK:
+ Info.mInfo.mVarOffset = 3;
+ break;
+ case TIME_HOUR_BITMASK:
+ Info.mInfo.mVarOffset = 0;
+ break;
+ case TIME_MINUTE_BITMASK:
+ Info.mInfo.mVarOffset = 1;
+ break;
+ case TIME_SECOND_BITMASK:
+ Info.mInfo.mVarOffset = 2;
+ break;
+ default:
+ _PCATCH(VFR_RETURN_UNSUPPORTED, L->getLine(), "Get/Set opcode can't get the enough varstore information");
+ break;
+ }
+ } else {
+ if ((gCVfrDataStorage.GetVarStoreType(Info.mVarStoreId) == EFI_VFR_VARSTORE_NAME) && (VarType == EFI_IFR_TYPE_UNDEFINED)) {
+ _PCATCH(VFR_RETURN_UNSUPPORTED, L->getLine(), "Get/Set opcode don't support name string");
+ }
+ if (VarType != EFI_IFR_TYPE_UNDEFINED) {
+ Info.mVarType = VarType;
+ _PCATCH(gCVfrVarDataTypeDB.GetDataTypeSize (Info.mVarType, &VarSize), L->getLine(), "Get/Set opcode can't get var type size");
+ Info.mVarTotalSize = VarSize;
+ }
+ _PCATCH(gCVfrVarDataTypeDB.GetDataTypeSize (Info.mVarType, &VarSize), L->getLine(), "Get/Set opcode can't get var type size");
+ if (VarSize != Info.mVarTotalSize) {
+ _PCATCH(VFR_RETURN_UNSUPPORTED, L->getLine(), "Get/Set opcode don't support data array");
+ }
+ }
+ CIfrGet GObj(L->getLine());
+ _SAVE_OPHDR_COND (GObj, ($ExpOpCount == 0), L->getLine());
+ GObj.SetVarInfo (&Info);
+ delete VarIdStr;
+ $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++; >>
@@ -2986,18 +4681,20 @@ vfrExpressionConstant[UINT32 & RootLevel, UINT32 & ExpOpCount] :
| L5:Zero << CIfrZero ZObj(L5->getLine()); _SAVE_OPHDR_COND (ZObj, ($ExpOpCount == 0), L5->getLine()); $ExpOpCount++; >>
| L6:Undefined << CIfrUndefined UObj(L6->getLine()); _SAVE_OPHDR_COND (UObj, ($ExpOpCount == 0), L6->getLine()); $ExpOpCount++; >>
| L7:Version << CIfrVersion VObj(L7->getLine()); _SAVE_OPHDR_COND (VObj, ($ExpOpCount == 0), L7->getLine()); $ExpOpCount++; >>
- | V:Number << CIfrUint64 U64Obj(V->getLine()); U64Obj.SetValue (_STOU64(V->getText())); _SAVE_OPHDR_COND (U64Obj, ($ExpOpCount == 0), V->getLine()); $ExpOpCount++; >>
+ | V:Number << CIfrUint64 U64Obj(V->getLine()); U64Obj.SetValue (_STOU64(V->getText(), V->getLine())); _SAVE_OPHDR_COND (U64Obj, ($ExpOpCount == 0), V->getLine()); $ExpOpCount++; >>
;
vfrExpressionUnaryOp[UINT32 & RootLevel, UINT32 & ExpOpCount] :
lengthExp[$RootLevel, $ExpOpCount]
| bitwisenotExp[$RootLevel, $ExpOpCount]
- | question2refExp[$RootLevel, $ExpOpCount]
+ | question23refExp[$RootLevel, $ExpOpCount]
| stringref2Exp[$RootLevel, $ExpOpCount]
| toboolExp[$RootLevel, $ExpOpCount]
+ | tostringExp[$RootLevel, $ExpOpCount]
| unintExp[$RootLevel, $ExpOpCount]
| toupperExp[$RootLevel, $ExpOpCount]
| tolwerExp[$RootLevel, $ExpOpCount]
+ | setExp[$RootLevel, $ExpOpCount]
;
lengthExp[UINT32 & RootLevel, UINT32 & ExpOpCount] :
@@ -3012,10 +4709,30 @@ bitwisenotExp[UINT32 & RootLevel, UINT32 & ExpOpCount] :
<< { CIfrBitWiseNot BWNObj(L->getLine()); $ExpOpCount++; } >>
;
-question2refExp[UINT32 & RootLevel, UINT32 & ExpOpCount] :
+question23refExp[UINT32 & RootLevel, UINT32 & ExpOpCount] :
+ <<
+ UINT8 Type = 0x1;
+ EFI_STRING_ID DevPath = EFI_STRING_ID_INVALID;
+ EFI_GUID Guid = {0,};
+ >>
L:QuestionRefVal
- "\(" vfrStatementExpressionSub[$RootLevel + 1, $ExpOpCount] "\)"
- << { CIfrQuestionRef2 QR2Obj(L->getLine()); $ExpOpCount++; } >>
+ "\("
+ {
+ DevicePath "=" "STRING_TOKEN" "\(" S:Number "\)" "," << Type = 0x2; DevPath = _STOSID(S->getText(), S->getLine()); >>
+ }
+ {
+ Uuid "=" guidDefinition[Guid] "," << Type = 0x3; >>
+ }
+ vfrStatementExpressionSub[$RootLevel + 1, $ExpOpCount]
+ "\)"
+ <<
+ switch (Type) {
+ case 0x1: {CIfrQuestionRef2 QR2Obj(L->getLine()); _SAVE_OPHDR_COND (QR2Obj, ($ExpOpCount == 0), L->getLine()); break;}
+ case 0x2: {CIfrQuestionRef3_2 QR3_2Obj(L->getLine()); _SAVE_OPHDR_COND (QR3_2Obj, ($ExpOpCount == 0), L->getLine()); QR3_2Obj.SetDevicePath (DevPath); break;}
+ case 0x3: {CIfrQuestionRef3_3 QR3_3Obj(L->getLine()); _SAVE_OPHDR_COND (QR3_3Obj, ($ExpOpCount == 0), L->getLine()); QR3_3Obj.SetDevicePath (DevPath); QR3_3Obj.SetGuid (&Guid); break;}
+ }
+ $ExpOpCount++;
+ >>
;
stringref2Exp[UINT32 & RootLevel, UINT32 & ExpOpCount] :
@@ -3034,7 +4751,7 @@ tostringExp[UINT32 & RootLevel, UINT32 & ExpOpCount] :
<< UINT8 Fmt = 0; >>
L:StringVal
{
- Format "=" F:Number "," << Fmt = _STOU8(F->getText()); >>
+ Format "=" F:Number "," << Fmt = _STOU8(F->getText(), F->getLine()); >>
}
"\(" vfrStatementExpressionSub[$RootLevel + 1, $ExpOpCount] "\)"
<< { CIfrToString TSObj(L->getLine()); TSObj.SetFormat (Fmt); $ExpOpCount++; } >>
@@ -3058,6 +4775,78 @@ tolwerExp[UINT32 & RootLevel, UINT32 & ExpOpCount] :
<< { CIfrToLower TLObj(L->getLine()); $ExpOpCount++; } >>
;
+setExp[UINT32 & RootLevel, UINT32 & ExpOpCount] :
+ <<
+ EFI_VARSTORE_INFO Info;
+ CHAR8 *VarIdStr = NULL;
+ EFI_QUESTION_ID QId = EFI_QUESTION_ID_INVALID;
+ UINT32 Mask = 0;
+ EFI_QUESION_TYPE QType = QUESTION_NORMAL;
+ UINT8 VarType = EFI_IFR_TYPE_UNDEFINED;
+ UINT32 VarSize = 0;
+ Info.mVarStoreId = 0;
+ >>
+ L:Set
+ "\("
+ vfrStorageVarId[Info, VarIdStr, FALSE]
+ {"\|" FLAG "=" numericVarStoreType [VarType] }
+ "," vfrStatementExpressionSub[$RootLevel + 1, $ExpOpCount]
+ "\)"
+ <<
+ {
+ if (Info.mVarStoreId == 0) {
+ // support Date/Time question
+ mCVfrQuestionDB.GetQuestionId (NULL, VarIdStr, QId, Mask, &QType);
+ if (QId == EFI_QUESTION_ID_INVALID || Mask == 0 || QType == QUESTION_NORMAL) {
+ _PCATCH(VFR_RETURN_UNSUPPORTED, L->getLine(), "Get/Set opcode can't get the enough varstore information");
+ }
+ if (QType == QUESTION_DATE) {
+ Info.mVarType = EFI_IFR_TYPE_DATE;
+ } else if (QType == QUESTION_TIME) {
+ Info.mVarType = EFI_IFR_TYPE_TIME;
+ }
+ switch (Mask) {
+ case DATE_YEAR_BITMASK:
+ Info.mInfo.mVarOffset = 0;
+ break;
+ case DATE_DAY_BITMASK:
+ Info.mInfo.mVarOffset = 3;
+ break;
+ case TIME_HOUR_BITMASK:
+ Info.mInfo.mVarOffset = 0;
+ break;
+ case TIME_MINUTE_BITMASK:
+ Info.mInfo.mVarOffset = 1;
+ break;
+ case TIME_SECOND_BITMASK:
+ Info.mInfo.mVarOffset = 2;
+ break;
+ default:
+ _PCATCH(VFR_RETURN_UNSUPPORTED, L->getLine(), "Get/Set opcode can't get the enough varstore information");
+ break;
+ }
+ } else {
+ if ((gCVfrDataStorage.GetVarStoreType(Info.mVarStoreId) == EFI_VFR_VARSTORE_NAME) && (VarType == EFI_IFR_TYPE_UNDEFINED)) {
+ _PCATCH(VFR_RETURN_UNSUPPORTED, L->getLine(), "Get/Set opcode don't support name string");
+ }
+ if (VarType != EFI_IFR_TYPE_UNDEFINED) {
+ Info.mVarType = VarType;
+ _PCATCH(gCVfrVarDataTypeDB.GetDataTypeSize (Info.mVarType, &VarSize), L->getLine(), "Get/Set opcode can't get var type size");
+ Info.mVarTotalSize = VarSize;
+ }
+ _PCATCH(gCVfrVarDataTypeDB.GetDataTypeSize (Info.mVarType, &VarSize), L->getLine(), "Get/Set opcode can't get var type size");
+ if (VarSize != Info.mVarTotalSize) {
+ _PCATCH(VFR_RETURN_UNSUPPORTED, L->getLine(), "Get/Set opcode don't support data array");
+ }
+ }
+ CIfrSet TSObj(L->getLine());
+ TSObj.SetVarInfo (&Info);
+ delete VarIdStr;
+ $ExpOpCount++;
+ }
+ >>
+ ;
+
vfrExpressionTernaryOp[UINT32 & RootLevel, UINT32 & ExpOpCount] :
conditionalExp[$RootLevel, $ExpOpCount]
| findExp[$RootLevel, $ExpOpCount]
@@ -3133,8 +4922,22 @@ spanExp[UINT32 & RootLevel, UINT32 & ExpOpCount] :
"\)" << { CIfrSpan SObj(S->getLine()); SObj.SetFlags(Flags); $ExpOpCount++; } >>
;
+vfrExpressionMap [UINT32 & RootLevel, UINT32 & ExpOpCount]:
+ L:Map
+ "\("
+ vfrStatementExpressionSub[$RootLevel + 1, $ExpOpCount]
+ ":" << { CIfrMap MObj(L->getLine()); } >>
+ (
+ vfrStatementExpression[0]
+ ","
+ vfrStatementExpression[0]
+ ";"
+ ) *
+ E:"\)" << { CIfrEnd EObj; EObj.SetLineNo(E->getLine()); $ExpOpCount++; } >>
+ ;
+
spanFlags [UINT8 & Flags] :
- N:Number << $Flags |= _STOU8(N->getText()); >>
+ N:Number << $Flags |= _STOU8(N->getText(), N->getLine()); >>
| "LAST_NON_MATCH" << $Flags |= 0x00; >>
| "FIRST_NON_MATCH" << $Flags |= 0x01; >>
;
@@ -3152,19 +4955,26 @@ private:
UINT8 mParserStatus;
BOOLEAN mConstantOnlyInExpression;
- CVfrDefaultStore mCVfrDefaultStore;
- CVfrDataStorage mCVfrDataStorage;
CVfrQuestionDB mCVfrQuestionDB;
CVfrRulesDB mCVfrRulesDB;
- CIfrOpHeader *mCIfrOpHdr;
- UINT32 mCIfrOpHdrLineNo;
+ CIfrOpHeader * mCIfrOpHdr[MAX_IFR_EXPRESSION_DEPTH];
+ UINT32 mCIfrOpHdrLineNo[MAX_IFR_EXPRESSION_DEPTH];
+ UINT8 mCIfrOpHdrIndex;
VOID _SAVE_OPHDR_COND (IN CIfrOpHeader &, IN BOOLEAN, UINT32 LineNo = 0);
VOID _CLEAR_SAVED_OPHDR (VOID);
BOOLEAN _SET_SAVED_OPHDR_SCOPE (VOID);
EFI_VARSTORE_INFO mCurrQestVarInfo;
+ EFI_GUID *mOverrideClassGuid;
+ CHAR8* mLastFormEndAddr;
+
+//
+// Whether the question already has default value.
+//
+ UINT16 mUsedDefaultArray[EFI_IFR_MAX_DEFAULT_TYPE];
+ UINT16 mUsedDefaultCount;
//
// For framework vfr compatibility
@@ -3179,30 +4989,33 @@ private:
UINT8 _GET_CURRQEST_DATATYPE ();
UINT32 _GET_CURRQEST_VARSIZE ();
+ UINT32 _GET_CURRQEST_ARRAY_SIZE();
+ VOID CheckDuplicateDefaultValue (IN EFI_DEFAULT_ID, IN ANTLRTokenPtr);
public:
- VOID _PCATCH (IN INTN, IN INTN, IN ANTLRTokenPtr, IN CHAR8 *);
+ VOID _PCATCH (IN INTN, IN INTN, IN ANTLRTokenPtr, IN CONST CHAR8 *);
VOID _PCATCH (IN EFI_VFR_RETURN_CODE);
VOID _PCATCH (IN EFI_VFR_RETURN_CODE, IN ANTLRTokenPtr);
VOID _PCATCH (IN EFI_VFR_RETURN_CODE, IN UINT32);
- VOID _PCATCH (IN EFI_VFR_RETURN_CODE, IN UINT32, IN CHAR8 *);
+ VOID _PCATCH (IN EFI_VFR_RETURN_CODE, IN UINT32, IN CONST CHAR8 *);
VOID syn (ANTLRAbstractToken *, ANTLRChar *, SetWordType *, ANTLRTokenType, INT32);
CHAR8* TrimHex (IN CHAR8 *, OUT BOOLEAN *);
CHAR8* _U32TOS (IN UINT32);
- UINT8 _STOU8 (IN CHAR8 *);
- UINT16 _STOU16 (IN CHAR8 *);
- UINT32 _STOU32 (IN CHAR8 *);
- UINT64 _STOU64 (IN CHAR8 *);
- EFI_HII_DATE _STOD (IN CHAR8 *, IN CHAR8 *, IN CHAR8 *);
- EFI_HII_TIME _STOT (IN CHAR8 *, IN CHAR8 *, IN CHAR8 *);
+ UINT8 _STOU8 (IN CHAR8 *, IN UINT32);
+ UINT16 _STOU16 (IN CHAR8 *, IN UINT32);
+ UINT32 _STOU32 (IN CHAR8 *, IN UINT32);
+ UINT64 _STOU64 (IN CHAR8 *, IN UINT32);
+ EFI_HII_DATE _STOD (IN CHAR8 *, IN CHAR8 *, IN CHAR8 *, IN UINT32);
+ EFI_HII_TIME _STOT (IN CHAR8 *, IN CHAR8 *, IN CHAR8 *, IN UINT32);
+ EFI_HII_REF _STOR (IN CHAR8 *, IN CHAR8 *, IN EFI_GUID *, IN CHAR8 *, IN UINT32);
- EFI_STRING_ID _STOSID (IN CHAR8 *);
- EFI_FORM_ID _STOFID (IN CHAR8 *);
- EFI_QUESTION_ID _STOQID (IN CHAR8 *);
+ EFI_STRING_ID _STOSID (IN CHAR8 *, IN UINT32);
+ EFI_FORM_ID _STOFID (IN CHAR8 *, IN UINT32);
+ EFI_QUESTION_ID _STOQID (IN CHAR8 *, IN UINT32);
- VOID _STRCAT (IN OUT CHAR8 **, IN CHAR8 *);
+ VOID _STRCAT (IN OUT CHAR8 **, IN CONST CHAR8 *);
VOID _DeclareDefaultLinearVarStore (IN UINT32);
VOID _DeclareStandardDefaultStorage (IN UINT32);
@@ -3214,6 +5027,7 @@ public:
VOID IdEqValDoSpecial (IN UINT32 &, IN UINT32, IN EFI_QUESTION_ID, IN CHAR8 *, IN UINT32, IN UINT16, IN EFI_COMPARE_TYPE);
VOID IdEqIdDoSpecial (IN UINT32 &, IN UINT32, IN EFI_QUESTION_ID, IN CHAR8 *, IN UINT32, IN EFI_QUESTION_ID, IN CHAR8 *, IN UINT32, IN EFI_COMPARE_TYPE);
VOID IdEqListDoSpecial (IN UINT32 &, IN UINT32, IN EFI_QUESTION_ID, IN CHAR8 *, IN UINT32, IN UINT16, IN UINT16 *);
+ VOID SetOverrideClassGuid (IN EFI_GUID *);
//
// For framework vfr compatibility
//
@@ -3230,11 +5044,11 @@ EfiVfrParser::_SAVE_OPHDR_COND (
)
{
if (Cond == TRUE) {
- if (mCIfrOpHdr != NULL) {
+ if (mCIfrOpHdr[mCIfrOpHdrIndex] != NULL) {
return ;
}
- mCIfrOpHdr = new CIfrOpHeader(OpHdr);
- mCIfrOpHdrLineNo = LineNo;
+ mCIfrOpHdr[mCIfrOpHdrIndex] = new CIfrOpHeader(OpHdr);
+ mCIfrOpHdrLineNo[mCIfrOpHdrIndex] = LineNo;
}
}
@@ -3243,8 +5057,8 @@ EfiVfrParser::_CLEAR_SAVED_OPHDR (
VOID
)
{
- mCIfrOpHdr = NULL;
- mCIfrOpHdrLineNo = 0;
+ mCIfrOpHdr[mCIfrOpHdrIndex] = NULL;
+ mCIfrOpHdrLineNo[mCIfrOpHdrIndex] = 0;
}
BOOLEAN
@@ -3252,10 +5066,11 @@ EfiVfrParser::_SET_SAVED_OPHDR_SCOPE (
VOID
)
{
- if (mCIfrOpHdr != NULL) {
- mCIfrOpHdr->SetScope (1);
+ if (mCIfrOpHdr[mCIfrOpHdrIndex] != NULL) {
+ mCIfrOpHdr[mCIfrOpHdrIndex]->SetScope (1);
return TRUE;
}
+
//
// IfrOpHdr is not set, FALSE is return.
//
@@ -3286,6 +5101,37 @@ EfiVfrParser::_GET_CURRQEST_VARTINFO (
return mCurrQestVarInfo;
}
+UINT32
+EfiVfrParser::_GET_CURRQEST_ARRAY_SIZE (
+ VOID
+ )
+{
+ UINT8 Size = 1;
+
+ switch (mCurrQestVarInfo.mVarType) {
+ case EFI_IFR_TYPE_NUM_SIZE_8:
+ Size = 1;
+ break;
+
+ case EFI_IFR_TYPE_NUM_SIZE_16:
+ Size = 2;
+ break;
+
+ case EFI_IFR_TYPE_NUM_SIZE_32:
+ Size = 4;
+ break;
+
+ case EFI_IFR_TYPE_NUM_SIZE_64:
+ Size = 8;
+ break;
+
+ default:
+ break;
+ }
+
+ return (mCurrQestVarInfo.mVarTotalSize / Size);
+}
+
UINT8
EfiVfrParser::_GET_CURRQEST_DATATYPE (
VOID
@@ -3307,7 +5153,7 @@ EfiVfrParser::_PCATCH (
IN INTN ReturnCode,
IN INTN ExpectCode,
IN ANTLRTokenPtr Tok,
- IN CHAR8 *ErrorMsg
+ IN CONST CHAR8 *ErrorMsg
)
{
if (ReturnCode != ExpectCode) {
@@ -3321,7 +5167,7 @@ EfiVfrParser::_PCATCH (
IN EFI_VFR_RETURN_CODE ReturnCode
)
{
- mParserStatus += gCVfrErrorHandle.HandleError (ReturnCode);
+ mParserStatus = mParserStatus + gCVfrErrorHandle.HandleError (ReturnCode);
}
VOID
@@ -3330,7 +5176,7 @@ EfiVfrParser::_PCATCH (
IN ANTLRTokenPtr Tok
)
{
- mParserStatus += gCVfrErrorHandle.HandleError (ReturnCode, Tok->getLine(), Tok->getText());
+ mParserStatus = mParserStatus + gCVfrErrorHandle.HandleError (ReturnCode, Tok->getLine(), Tok->getText());
}
VOID
@@ -3339,17 +5185,17 @@ EfiVfrParser::_PCATCH (
IN UINT32 LineNum
)
{
- mParserStatus += gCVfrErrorHandle.HandleError (ReturnCode, LineNum);
+ mParserStatus = mParserStatus + gCVfrErrorHandle.HandleError (ReturnCode, LineNum);
}
VOID
EfiVfrParser::_PCATCH (
IN EFI_VFR_RETURN_CODE ReturnCode,
IN UINT32 LineNum,
- IN CHAR8 *ErrorMsg
+ IN CONST CHAR8 *ErrorMsg
)
{
- mParserStatus += gCVfrErrorHandle.HandleError (ReturnCode, LineNum, ErrorMsg);
+ mParserStatus = mParserStatus + gCVfrErrorHandle.HandleError (ReturnCode, LineNum, (CHAR8 *) ErrorMsg);
}
VOID
@@ -3401,18 +5247,21 @@ EfiVfrParser::_U32TOS (
UINT8
EfiVfrParser::_STOU8 (
- IN CHAR8*Str
+ IN CHAR8 *Str,
+ IN UINT32 LineNum
)
{
BOOLEAN IsHex;
UINT8 Value;
CHAR8 c;
+ UINT8 PreviousValue;
+ CHAR8 *OrigString = Str;
+ CHAR8 ErrorMsg[100];
+
Str = TrimHex (Str, &IsHex);
for (Value = 0; (c = *Str) != '\0'; Str++) {
- //
- // BUG: does not handle overflow here
- //
+ PreviousValue = Value;
(IsHex == TRUE) ? (Value <<= 4) : (Value *= 10);
if ((IsHex == TRUE) && (c >= 'a') && (c <= 'f')) {
@@ -3424,6 +5273,10 @@ EfiVfrParser::_STOU8 (
if (c >= '0' && c <= '9') {
Value += (c - '0');
}
+ if((IsHex && ((Value/16) != PreviousValue)) || (!IsHex && ((Value/10) != PreviousValue))) {
+ sprintf(ErrorMsg, "Overflow: Value %s is too large to store in a UINT8", OrigString);
+ gCVfrErrorHandle.HandleWarning (VFR_WARNING_STRING_TO_UINT_OVERFLOW, LineNum, ErrorMsg);
+ }
}
return Value;
@@ -3431,18 +5284,21 @@ EfiVfrParser::_STOU8 (
UINT16
EfiVfrParser::_STOU16 (
- IN CHAR8*Str
+ IN CHAR8 *Str,
+ IN UINT32 LineNum
)
{
BOOLEAN IsHex;
UINT16 Value;
CHAR8 c;
+ UINT16 PreviousValue;
+ CHAR8 *OrigString = Str;
+ CHAR8 ErrorMsg[100];
+
Str = TrimHex (Str, &IsHex);
for (Value = 0; (c = *Str) != '\0'; Str++) {
- //
- // BUG: does not handle overflow here
- //
+ PreviousValue = Value;
(IsHex == TRUE) ? (Value <<= 4) : (Value *= 10);
if ((IsHex == TRUE) && (c >= 'a') && (c <= 'f')) {
@@ -3454,6 +5310,10 @@ EfiVfrParser::_STOU16 (
if (c >= '0' && c <= '9') {
Value += (c - '0');
}
+ if((IsHex && ((Value/16) != PreviousValue)) || (!IsHex && ((Value/10) != PreviousValue))) {
+ sprintf(ErrorMsg, "Overflow: Value %s is too large to store in a UINT16", OrigString);
+ gCVfrErrorHandle.HandleWarning (VFR_WARNING_STRING_TO_UINT_OVERFLOW, LineNum, ErrorMsg);
+ }
}
return Value;
@@ -3461,18 +5321,21 @@ EfiVfrParser::_STOU16 (
UINT32
EfiVfrParser::_STOU32 (
- IN CHAR8*Str
+ IN CHAR8 *Str,
+ IN UINT32 LineNum
)
{
BOOLEAN IsHex;
UINT32 Value;
CHAR8 c;
+ UINT32 PreviousValue;
+ CHAR8 *OrigString = Str;
+ CHAR8 ErrorMsg[100];
+
Str = TrimHex (Str, &IsHex);
for (Value = 0; (c = *Str) != '\0'; Str++) {
- //
- // BUG: does not handle overflow here
- //
+ PreviousValue = Value;
(IsHex == TRUE) ? (Value <<= 4) : (Value *= 10);
if ((IsHex == TRUE) && (c >= 'a') && (c <= 'f')) {
@@ -3484,6 +5347,10 @@ EfiVfrParser::_STOU32 (
if (c >= '0' && c <= '9') {
Value += (c - '0');
}
+ if((IsHex && ((Value/16) != PreviousValue)) || (!IsHex && ((Value/10) != PreviousValue ))) {
+ sprintf(ErrorMsg, "Overflow: Value %s is too large to store in a UINT32", OrigString);
+ gCVfrErrorHandle.HandleWarning (VFR_WARNING_STRING_TO_UINT_OVERFLOW, LineNum, ErrorMsg);
+ }
}
return Value;
@@ -3491,18 +5358,20 @@ EfiVfrParser::_STOU32 (
UINT64
EfiVfrParser::_STOU64 (
- IN CHAR8*Str
+ IN CHAR8 *Str,
+ IN UINT32 LineNum
)
{
BOOLEAN IsHex;
UINT64 Value;
CHAR8 c;
+ UINT64 PreviousValue;
+ CHAR8 *OrigString = Str;
+ CHAR8 ErrorMsg[100];
Str = TrimHex (Str, &IsHex);
for (Value = 0; (c = *Str) != '\0'; Str++) {
- //
- // BUG: does not handle overflow here
- //
+ PreviousValue = Value;
(IsHex == TRUE) ? (Value <<= 4) : (Value *= 10);
if ((IsHex == TRUE) && (c >= 'a') && (c <= 'f')) {
@@ -3514,6 +5383,10 @@ EfiVfrParser::_STOU64 (
if (c >= '0' && c <= '9') {
Value += (c - '0');
}
+ if((IsHex && ((Value/16) != PreviousValue)) || ((!IsHex && (Value/10) != PreviousValue))) {
+ sprintf(ErrorMsg, "Overflow: Value %s is too large to store in a UINT64", OrigString);
+ gCVfrErrorHandle.HandleWarning (VFR_WARNING_STRING_TO_UINT_OVERFLOW, LineNum, ErrorMsg);
+ }
}
return Value;
@@ -3523,14 +5396,15 @@ EFI_HII_DATE
EfiVfrParser::_STOD (
IN CHAR8 *Year,
IN CHAR8 *Month,
- IN CHAR8 *Day
+ IN CHAR8 *Day,
+ IN UINT32 LineNum
)
{
EFI_HII_DATE Date;
- Date.Year = _STOU16 (Year);
- Date.Month = _STOU8 (Month);
- Date.Day = _STOU8 (Day);
+ Date.Year = _STOU16 (Year, LineNum);
+ Date.Month = _STOU8 (Month, LineNum);
+ Date.Day = _STOU8 (Day, LineNum);
return Date;
}
@@ -3539,46 +5413,50 @@ EFI_HII_TIME
EfiVfrParser::_STOT (
IN CHAR8 *Hour,
IN CHAR8 *Minute,
- IN CHAR8 *Second
+ IN CHAR8 *Second,
+ IN UINT32 LineNum
)
{
EFI_HII_TIME Time;
- Time.Hour = _STOU8 (Hour);
- Time.Minute = _STOU8 (Minute);
- Time.Second = _STOU8 (Second);
+ Time.Hour = _STOU8 (Hour, LineNum);
+ Time.Minute = _STOU8 (Minute, LineNum);
+ Time.Second = _STOU8 (Second, LineNum);
return Time;
}
EFI_STRING_ID
EfiVfrParser::_STOSID (
- IN CHAR8 *Str
+ IN CHAR8 *Str,
+ IN UINT32 LineNum
)
{
- return (EFI_STRING_ID)_STOU16(Str);
+ return (EFI_STRING_ID)_STOU16(Str, LineNum);
}
EFI_FORM_ID
EfiVfrParser::_STOFID (
- IN CHAR8 *Str
+ IN CHAR8 *Str,
+ IN UINT32 LineNum
)
{
- return (EFI_FORM_ID)_STOU16(Str);
+ return (EFI_FORM_ID)_STOU16(Str, LineNum);
}
EFI_QUESTION_ID
EfiVfrParser::_STOQID (
- IN CHAR8 *Str
+ IN CHAR8 *Str,
+ IN UINT32 LineNum
)
{
- return (EFI_QUESTION_ID)_STOU16(Str);
+ return (EFI_QUESTION_ID)_STOU16(Str, LineNum);
}
VOID
EfiVfrParser::_STRCAT (
IN OUT CHAR8 **Dest,
- IN CHAR8 *Src
+ IN CONST CHAR8 *Src
)
{
CHAR8 *NewStr;
@@ -3603,6 +5481,26 @@ EfiVfrParser::_STRCAT (
*Dest = NewStr;
}
+EFI_HII_REF
+EfiVfrParser::_STOR (
+ IN CHAR8 *QuestionId,
+ IN CHAR8 *FormId,
+ IN EFI_GUID *FormSetGuid,
+ IN CHAR8 *DevicePath,
+ IN UINT32 LineNum
+ )
+{
+ EFI_HII_REF Ref;
+ UINT32 Index;
+
+ memcpy (&Ref.FormSetGuid, FormSetGuid, sizeof (EFI_GUID));
+ Ref.QuestionId = _STOQID (QuestionId, LineNum);
+ Ref.FormId = _STOFID (FormId, LineNum);
+ Ref.DevicePath = _STOSID (DevicePath, LineNum);
+
+ return Ref;
+}
+
//
// framework vfr to default declare varstore for each structure
//
@@ -3614,9 +5512,10 @@ EfiVfrParser::_DeclareDefaultFrameworkVarStore (
SVfrVarStorageNode *pNode;
UINT32 TypeSize;
BOOLEAN FirstNode;
+ CONST CHAR8 VarName[] = "Setup";
FirstNode = TRUE;
- pNode = mCVfrDataStorage.GetBufferVarStoreList();
+ pNode = gCVfrDataStorage.GetBufferVarStoreList();
if (pNode == NULL && gCVfrVarDataTypeDB.mFirstNewDataTypeName != NULL) {
//
// Create the default Buffer Var Store when no VarStore is defined.
@@ -3626,9 +5525,9 @@ EfiVfrParser::_DeclareDefaultFrameworkVarStore (
CIfrVarStore VSObj;
VSObj.SetLineNo (LineNo);
VSObj.SetVarStoreId (0x1); //the first and only one Buffer Var Store
- VSObj.SetSize (TypeSize);
+ VSObj.SetSize ((UINT16) TypeSize);
//VSObj.SetName (gCVfrVarDataTypeDB.mFirstNewDataTypeName);
- VSObj.SetName ("Setup");
+ VSObj.SetName ((CHAR8 *) VarName);
VSObj.SetGuid (&mFormsetGuid);
#ifdef VFREXP_DEBUG
printf ("Create the default VarStoreName is %s\n", gCVfrVarDataTypeDB.mFirstNewDataTypeName);
@@ -3643,9 +5542,9 @@ EfiVfrParser::_DeclareDefaultFrameworkVarStore (
CIfrVarStore VSObj;
VSObj.SetLineNo (LineNo);
VSObj.SetVarStoreId (pNode->mVarStoreId);
- VSObj.SetSize (pNode->mStorageInfo.mDataType->mTotalSize);
+ VSObj.SetSize ((UINT16) pNode->mStorageInfo.mDataType->mTotalSize);
if (FirstNode) {
- VSObj.SetName ("Setup");
+ VSObj.SetName ((CHAR8 *) VarName);
FirstNode = FALSE;
} else {
VSObj.SetName (pNode->mVarStoreName);
@@ -3658,7 +5557,7 @@ EfiVfrParser::_DeclareDefaultFrameworkVarStore (
}
}
- pNode = mCVfrDataStorage.GetEfiVarStoreList();
+ pNode = gCVfrDataStorage.GetEfiVarStoreList();
for (; pNode != NULL; pNode = pNode->mNext) {
//
// create the default efi varstore opcode for not exist varstore
@@ -3669,6 +5568,9 @@ EfiVfrParser::_DeclareDefaultFrameworkVarStore (
VSEObj.SetAttributes (0x00000002); //hardcode EFI_VARIABLE_BOOTSERVICE_ACCESS attribute
VSEObj.SetGuid (&pNode->mGuid);
VSEObj.SetVarStoreId (pNode->mVarStoreId);
+ // Generate old efi varstore storage structure for compatiable with old "VarEqVal" opcode,
+ // which is 3 bytes less than new structure define in UEFI Spec 2.3.1.
+ VSEObj.SetBinaryLength (sizeof (EFI_IFR_VARSTORE_EFI) - 3);
#ifdef VFREXP_DEBUG
printf ("undefined Efi VarStoreName is %s and Id is 0x%x\n", pNode->mVarStoreName, pNode->mVarStoreId);
#endif
@@ -3685,6 +5587,10 @@ EfiVfrParser::_DeclareDefaultLinearVarStore (
UINT32 Index;
CHAR8 **TypeNameList;
UINT32 ListSize;
+ CONST CHAR8 DateName[] = "Date";
+ CONST CHAR8 TimeName[] = "Time";
+ CONST CHAR8 DateType[] = "EFI_HII_DATE";
+ CONST CHAR8 TimeType[] = "EFI_HII_TIME";
gCVfrVarDataTypeDB.GetUserDefinedTypeNameList (&TypeNameList, &ListSize);
@@ -3694,17 +5600,18 @@ EfiVfrParser::_DeclareDefaultLinearVarStore (
CIfrVarStore VSObj;
VSObj.SetLineNo (LineNo);
- mCVfrDataStorage.DeclareBufferVarStore (
+ gCVfrDataStorage.DeclareBufferVarStore (
TypeNameList[Index],
&mFormsetGuid,
&gCVfrVarDataTypeDB,
TypeNameList[Index],
- EFI_VARSTORE_ID_INVALID
+ EFI_VARSTORE_ID_INVALID,
+ FALSE
);
- mCVfrDataStorage.GetVarStoreId(TypeNameList[Index], &VarStoreId);
+ gCVfrDataStorage.GetVarStoreId(TypeNameList[Index], &VarStoreId, &mFormsetGuid);
VSObj.SetVarStoreId (VarStoreId);
gCVfrVarDataTypeDB.GetDataTypeSize(TypeNameList[Index], &Size);
- VSObj.SetSize (Size);
+ VSObj.SetSize ((UINT16) Size);
VSObj.SetName (TypeNameList[Index]);
VSObj.SetGuid (&mFormsetGuid);
}
@@ -3713,45 +5620,47 @@ EfiVfrParser::_DeclareDefaultLinearVarStore (
// not required to declare Date and Time VarStore,
// because code to support old format Data and Time
//
- if (gCVfrVarDataTypeDB.IsTypeNameDefined ("Date") == FALSE) {
+ if (gCVfrVarDataTypeDB.IsTypeNameDefined ((CHAR8 *) DateName) == FALSE) {
UINT32 Size;
EFI_VARSTORE_ID VarStoreId;
CIfrVarStore VSObj;
VSObj.SetLineNo (LineNo);
- mCVfrDataStorage.DeclareBufferVarStore (
- "Date",
+ gCVfrDataStorage.DeclareBufferVarStore (
+ (CHAR8 *) DateName,
&mFormsetGuid,
&gCVfrVarDataTypeDB,
- "EFI_HII_DATE",
- EFI_VARSTORE_ID_INVALID
+ (CHAR8 *) DateType,
+ EFI_VARSTORE_ID_INVALID,
+ FALSE
);
- mCVfrDataStorage.GetVarStoreId("Date", &VarStoreId);
+ gCVfrDataStorage.GetVarStoreId((CHAR8 *) DateName, &VarStoreId, &mFormsetGuid);
VSObj.SetVarStoreId (VarStoreId);
- gCVfrVarDataTypeDB.GetDataTypeSize("EFI_HII_DATE", &Size);
- VSObj.SetSize (Size);
- VSObj.SetName ("Date");
+ gCVfrVarDataTypeDB.GetDataTypeSize((CHAR8 *) DateType, &Size);
+ VSObj.SetSize ((UINT16) Size);
+ VSObj.SetName ((CHAR8 *) DateName);
VSObj.SetGuid (&mFormsetGuid);
}
- if (gCVfrVarDataTypeDB.IsTypeNameDefined ("Time") == FALSE) {
+ if (gCVfrVarDataTypeDB.IsTypeNameDefined ((CHAR8 *) TimeName) == FALSE) {
UINT32 Size;
EFI_VARSTORE_ID VarStoreId;
CIfrVarStore VSObj;
VSObj.SetLineNo (LineNo);
- mCVfrDataStorage.DeclareBufferVarStore (
- "Time",
+ gCVfrDataStorage.DeclareBufferVarStore (
+ (CHAR8 *) TimeName,
&mFormsetGuid,
&gCVfrVarDataTypeDB,
- "EFI_HII_TIME",
- EFI_VARSTORE_ID_INVALID
+ (CHAR8 *) TimeType,
+ EFI_VARSTORE_ID_INVALID,
+ FALSE
);
- mCVfrDataStorage.GetVarStoreId("Time", &VarStoreId);
+ gCVfrDataStorage.GetVarStoreId((CHAR8 *) TimeName, &VarStoreId, &mFormsetGuid);
VSObj.SetVarStoreId (VarStoreId);
- gCVfrVarDataTypeDB.GetDataTypeSize("EFI_HII_TIME", &Size);
- VSObj.SetSize (Size);
- VSObj.SetName ("Time");
+ gCVfrVarDataTypeDB.GetDataTypeSize((CHAR8 *) TimeType, &Size);
+ VSObj.SetSize ((UINT16) Size);
+ VSObj.SetName ((CHAR8 *) TimeName);
VSObj.SetGuid (&mFormsetGuid);
}
}
@@ -3766,7 +5675,7 @@ EfiVfrParser::_DeclareStandardDefaultStorage (
//
CIfrDefaultStore DSObj;
- mCVfrDefaultStore.RegisterDefaultStore (DSObj.GetObjBinAddr(), "Standard Defaults", EFI_STRING_ID_INVALID, EFI_HII_DEFAULT_CLASS_STANDARD);
+ gCVfrDefaultStore.RegisterDefaultStore (DSObj.GetObjBinAddr(), (CHAR8 *) "Standard Defaults", EFI_STRING_ID_INVALID, EFI_HII_DEFAULT_CLASS_STANDARD);
DSObj.SetLineNo (LineNo);
DSObj.SetDefaultName (EFI_STRING_ID_INVALID);
DSObj.SetDefaultId (EFI_HII_DEFAULT_CLASS_STANDARD);
@@ -3776,7 +5685,7 @@ EfiVfrParser::_DeclareStandardDefaultStorage (
//
CIfrDefaultStore DSObjMF;
- mCVfrDefaultStore.RegisterDefaultStore (DSObjMF.GetObjBinAddr(), "Standard ManuFacturing", EFI_STRING_ID_INVALID, EFI_HII_DEFAULT_CLASS_MANUFACTURING);
+ gCVfrDefaultStore.RegisterDefaultStore (DSObjMF.GetObjBinAddr(), (CHAR8 *) "Standard ManuFacturing", EFI_STRING_ID_INVALID, EFI_HII_DEFAULT_CLASS_MANUFACTURING);
DSObjMF.SetLineNo (LineNo);
DSObjMF.SetDefaultName (EFI_STRING_ID_INVALID);
DSObjMF.SetDefaultId (EFI_HII_DEFAULT_CLASS_MANUFACTURING);
@@ -3794,7 +5703,7 @@ EfiVfrParser::AssignQuestionKey (
return;
}
- KeyValue = _STOU16 (KeyTok->getText());
+ KeyValue = _STOU16 (KeyTok->getText(), KeyTok->getLine());
if (QHObj.FLAGS () & EFI_IFR_FLAG_CALLBACK) {
/*
@@ -3963,6 +5872,12 @@ EfiVfrParser::IdEqListDoSpecial (
}
}
+VOID
+EfiVfrParser::SetOverrideClassGuid (IN EFI_GUID *OverrideClassGuid)
+{
+ mOverrideClassGuid = OverrideClassGuid;
+}
+
//
// For framework vfr compatibility
//
@@ -3972,4 +5887,25 @@ EfiVfrParser::SetCompatibleMode (IN BOOLEAN Mode)
mCompatibleMode = Mode;
mCVfrQuestionDB.SetCompatibleMode (Mode);
}
+
+VOID
+EfiVfrParser::CheckDuplicateDefaultValue (
+ IN EFI_DEFAULT_ID DefaultId,
+ IN ANTLRTokenPtr Tok
+ )
+{
+ UINT16 Index;
+
+ for(Index = 0; Index < mUsedDefaultCount; Index++) {
+ if (mUsedDefaultArray[Index] == DefaultId) {
+ gCVfrErrorHandle.HandleWarning (VFR_WARNING_DEFAULT_VALUE_REDEFINED, Tok->getLine(), Tok->getText());
+ }
+ }
+
+ if (mUsedDefaultCount >= EFI_IFR_MAX_DEFAULT_TYPE - 1) {
+ gCVfrErrorHandle.HandleError (VFR_RETURN_FATAL_ERROR, Tok->getLine(), Tok->getText());
+ }
+
+ mUsedDefaultArray[mUsedDefaultCount++] = DefaultId;
+}
>>