#header<<

#include "EfiVfr.h"

#include "VfrFormPkg.h"

#include "VfrError.h"

#include "VfrUtilityLib.h"

#include "AToken.h"

#include "ATokPtr.h"

>>

<<

#include "stdio.h"

#include "PBlackBox.h"

#include "DLexerBase.h"

#include "VfrLexer.h"

#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)

typedef ANTLRCommonToken ANTLRToken;

class CVfrDLGLexer : public VfrLexer

{

public:

CVfrDLGLexer (DLGFileInput *F) : VfrLexer (F) {};

INT32 errstd (char *Text)

{

printf ("unrecognized input '%s'\n", Text);

}

};

VfrParserStart (

IN FILE *File,

IN INPUT_INFO_TO_SYNTAX *InputInfo

)

{

ParserBlackBox<CVfrDLGLexer, EfiVfrParser, ANTLRToken> VfrParser(File);

VfrParser.parser()->SetCompatibleMode (InputInfo->CompatibleMode);

VfrParser.parser()->SetOverrideClassGuid (InputInfo->OverrideClassGuid);

return VfrParser.parser()->vfrProgram();

}

>>

#lexclass QUOTED_STRING

#token TheString "~[\"]*\"" << mode (START); >>

#lexclass CPP_COMMENT

#token "~[\n]*" << skip (); >>

#token "\n" << skip (); mode (START); newline (); >>

#lexclass START

#token "//" << skip (); mode (CPP_COMMENT); >>

#token "[\ \t]" << skip (); >>

#token "\n" << skip (); newline (); >>

#token "extern" << skip (); mode (CPP_COMMENT); >>

#token FormPkgType("formpkgtype") "formpkgtype"

#token OpenBrace("{") "\{"

#token CloseBrace("}") "\}"

#token OpenParen("(") "\("

#token CloseParen(")") "\)"

#token OpenBracket("[") "\["

#token CloseBracket("]") "\]"

#token LineDefinition "#line\ [0-9]+\ \"~[\"]+\"[\ \t]*\n" << gCVfrErrorHandle.ParseFileScopeRecord (begexpr (), line ()); skip (); newline (); >>

#token DevicePath("devicepath") "devicepath"

#token FormSet("formset") "formset"

#token FormSetId("formsetid") "formsetid"

#token EndFormSet("endformset") "endformset"

#token Title("title") "title"

#token FormId("formid") "formid"

#token OneOf("oneof") "oneof"

#token EndOneOf("endoneof") "endoneof"

#token Prompt("prompt") "prompt"

#token OrderedList("orderedlist") "orderedlist"

#token MaxContainers("maxcontainers") "maxcontainers"

#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 Help("help") "help"

#token Text("text") "text"

#token Option("option") "option"

#token FLAGS("flags") "flags"

#token Date("date") "date"

#token EndDate("enddate") "enddate"

#token Year("year") "year"

#token Month("month") "month"

#token Day("day") "day"

#token Time("time") "time"

#token EndTime("endtime") "endtime"

#token Hour("hour") "hour"

#token Minute("minute") "minute"

#token Second("second") "second"

#token GrayOutIf("grayoutif") "grayoutif"

#token Label("label") "label"

#token Timeout("timeout") "timeout"

#token Inventory("inventory") "inventory"

#token NonNvDataMap("_NON_NV_DATA_MAP") "_NON_NV_DATA_MAP"

#token Struct("struct") "struct"

#token Boolean("BOOLEAN") "BOOLEAN"

#token Uint64("UINT64") "UINT64"

#token Uint32("UINT32") "UINT32"

#token Uint16("UINT16") "UINT16"

#token Char16("CHAR16") "CHAR16"

#token Uint8("UINT8") "UINT8"

#token Uuid("guid") "guid"

#token CheckBox("checkbox") "checkbox"

#token EndCheckBox("endcheckbox") "endcheckbox"

#token Numeric("numeric") "numeric"

#token EndNumeric("endnumeric") "endnumeric"

#token Minimum("minimum") "minimum"

#token Maximum("maximum") "maximum"

#token STEP("step") "step"

#token Default("default") "default"

#token Password("password") "password"

#token EndPassword("endpassword") "endpassword"

#token String("string") "string"

#token EndString("endstring") "endstring"

#token MinSize("minsize") "minsize"

#token MaxSize("maxsize") "maxsize"

#token Encoding("encoding") "encoding"

#token SuppressIf("suppressif") "suppressif"

#token DisableIf("disableif") "disableif"

#token Hidden("hidden") "hidden"

#token Goto("goto") "goto"

#token FormSetGuid("formsetguid") "formsetguid"

#token InconsistentIf("inconsistentif") "inconsistentif"

#token NoSubmitIf("nosubmitif") "nosubmitif"

#token EndIf("endif") "endif"

#token Key("key") "key"

#token DefaultFlag("DEFAULT") "DEFAULT"

#token ManufacturingFlag("MANUFACTURING") "MANUFACTURING"

#token InteractiveFlag("INTERACTIVE") "INTERACTIVE"

#token NVAccessFlag("NV_ACCESS") "NV_ACCESS"

#token ResetRequiredFlag("RESET_REQUIRED") "RESET_REQUIRED"

#token LateCheckFlag("LATE_CHECK") "LATE_CHECK"

#token ReadOnlyFlag("READ_ONLY") "READ_ONLY"

#token OptionOnlyFlag("OPTIONS_ONLY") "OPTIONS_ONLY"

#token Class("class") "class"

#token Subclass("subclass") "subclass"

#token ClassGuid("classguid") "classguid"

#token TypeDef("typedef") "typedef"

#token Restore("restore") "restore"

#token Save("save") "save"

#token Defaults("defaults") "defaults"

#token Banner("banner") "banner"

#token Align("align") "align"

#token Left("left") "left"

#token Right("right") "right"

#token Center("center") "center"

#token Line("line") "line"

#token Name("name") "name"

#token VarId("varid") "varid"

#token Question("question") "question"

#token QuestionId("questionid") "questionid"

#token Image("image") "image"

#token Locked("locked") "locked"

#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"

#token Attribute("attribute") "attribute"

#token Varstore("varstore") "varstore"

#token Efivarstore("efivarstore") "efivarstore"

#token VarSize("varsize") "varsize"

#token NameValueVarStore("namevaluevarstore") "namevaluevarstore"

#token Action("action") "action"

#token Config("config") "config"

#token EndAction("endaction") "endaction"

#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"

#token ClassNonDevice("NONDEVICE") "NON_DEVICE"

#token ClassDiskDevice("DISK_DEVICE") "DISK_DEVICE"

#token ClassVideoDevice("VIDEO_DEVICE") "VIDEO_DEVICE"

#token ClassNetworkDevice("NETWORK_DEVICE") "NETWORK_DEVICE"

#token ClassInputDevice("INPUT_DEVICE") "INPUT_DEVICE"

#token ClassOnBoardDevice("ONBOARD_DEVICE") "ONBOARD_DEVICE"

#token ClassOtherDevice("OTHER_DEVICE") "OTHER_DEVICE"

#token SubclassSetupApplication("SETUP_APPLICATION") "SETUP_APPLICATION"

#token SubclassGeneralApplication("GENERAL_APPLICATION") "GENERAL_APPLICATION"

#token SubclassFrontPage("FRONT_PAGE") "FRONT_PAGE"

#token SubclassSingleUse("SINGLE_USE") "SINGLE_USE"

vfrProgram > [UINT8 Return] :

<<

mParserStatus = 0;

mCIfrOpHdrIndex = 0;

mConstantOnlyInExpression = FALSE;

>>

(

vfrPragmaPackDefinition

| vfrDataStructDefinition

)*

vfrFormSetDefinition

<< $Return = mParserStatus; >>

;

pragmaPackShowDef :

L:"show" << gCVfrVarDataTypeDB.Pack (L->getLine(), VFR_PACK_SHOW); >>

;

pragmaPackStackDef :

<<

UINT32 LineNum;

UINT8 PackAction;

CHAR8 *Identifier = NULL;

UINT32 PackNumber = DEFAULT_PACK_ALIGN;

>>

(

L1:"push" << LineNum = L1->getLine(); PackAction = VFR_PACK_PUSH; >>

| L2:"pop" << LineNum = L2->getLine(); PackAction = VFR_PACK_POP; >>

)

{

"," ID:StringIdentifier << Identifier = ID->getText(); >>

}

{

"," N:Number << PackAction |= VFR_PACK_ASSIGN; PackNumber = _STOU32(N->getText()); >>

}

<< gCVfrVarDataTypeDB.Pack (LineNum, PackAction, Identifier, PackNumber); >>

;

pragmaPackNumber :

<<

UINT32 LineNum;

UINT32 PackNumber = DEFAULT_PACK_ALIGN;

>>

N:Number << LineNum = N->getLine(); PackNumber = _STOU32(N->getText()); >>

<< gCVfrVarDataTypeDB.Pack (LineNum, VFR_PACK_ASSIGN, NULL, PackNumber); >>

;

vfrPragmaPackDefinition :

"\#pragma" "pack" "\("

{

pragmaPackShowDef

| pragmaPackStackDef

| pragmaPackNumber

}

"\)"

;

vfrDataStructDefinition :

{ TypeDef } Struct << gCVfrVarDataTypeDB.DeclareDataTypeBegin (); >>

{ NonNvDataMap }

{

N1:StringIdentifier << _PCATCH(gCVfrVarDataTypeDB.SetNewTypeName (N1->getText()), N1); >>

}

OpenBrace

vfrDataStructFields

CloseBrace

{

N2:StringIdentifier << _PCATCH(gCVfrVarDataTypeDB.SetNewTypeName (N2->getText()), N2); >>

}

";" << gCVfrVarDataTypeDB.DeclareDataTypeEnd (); >>

;

vfrDataStructFields :

(

dataStructField64 |

dataStructField32 |

dataStructField16 |

dataStructField8 |

dataStructFieldBool |

dataStructFieldString |

dataStructFieldDate |

dataStructFieldTime |

dataStructFieldRef |

dataStructFieldUser

)*

;

dataStructField64 :

<< UINT32 ArrayNum = 0; >>

D:"UINT64"

N:StringIdentifier

{

OpenBracket I:Number CloseBracket << ArrayNum = _STOU32(I->getText()); >>

}

";" << _PCATCH(gCVfrVarDataTypeDB.DataTypeAddField (N->getText(), D->getText(), ArrayNum), N); >>

;

dataStructField32 :

<< UINT32 ArrayNum = 0; >>

D:"UINT32"

N:StringIdentifier

{

OpenBracket I:Number CloseBracket << ArrayNum = _STOU32(I->getText()); >>

}

";" << _PCATCH(gCVfrVarDataTypeDB.DataTypeAddField (N->getText(), D->getText(), ArrayNum), N); >>

;

dataStructField16 :

<<

UINT32 ArrayNum = 0;

>>

("UINT16" | "CHAR16")

N:StringIdentifier

{

OpenBracket I:Number CloseBracket << ArrayNum = _STOU32(I->getText()); >>

}

";" << _PCATCH(gCVfrVarDataTypeDB.DataTypeAddField (N->getText(), (CHAR8 *) "UINT16", ArrayNum), N); >>

;

dataStructField8 :

<< UINT32 ArrayNum = 0; >>

D:"UINT8"

N:StringIdentifier

{

OpenBracket I:Number CloseBracket << ArrayNum = _STOU32(I->getText()); >>

}

";" << _PCATCH(gCVfrVarDataTypeDB.DataTypeAddField (N->getText(), D->getText(), ArrayNum), N); >>

;

dataStructFieldBool :

<< UINT32 ArrayNum = 0; >>

D:"BOOLEAN"

N:StringIdentifier

{

OpenBracket I:Number CloseBracket << ArrayNum = _STOU32(I->getText()); >>

}

";" << _PCATCH(gCVfrVarDataTypeDB.DataTypeAddField (N->getText(), D->getText(), ArrayNum), N); >>

;

dataStructFieldString :

<< UINT32 ArrayNum = 0; >>

D:"EFI_STRING_ID"

N:StringIdentifier

{

OpenBracket I:Number CloseBracket << ArrayNum = _STOU32(I->getText()); >>

}

";" << _PCATCH(gCVfrVarDataTypeDB.DataTypeAddField (N->getText(), D->getText(), ArrayNum), N); >>

;

dataStructFieldDate :

<< UINT32 ArrayNum = 0; >>

D:"EFI_HII_DATE"

N:StringIdentifier

{

OpenBracket I:Number CloseBracket << ArrayNum = _STOU32(I->getText()); >>

}

";" << _PCATCH(gCVfrVarDataTypeDB.DataTypeAddField (N->getText(), D->getText(), ArrayNum), N); >>

;

dataStructFieldTime :

<< UINT32 ArrayNum = 0; >>

D:"EFI_HII_TIME"

N:StringIdentifier

{

OpenBracket I:Number CloseBracket << ArrayNum = _STOU32(I->getText()); >>

}

";" << _PCATCH(gCVfrVarDataTypeDB.DataTypeAddField (N->getText(), D->getText(), ArrayNum), N); >>

;

dataStructFieldRef :

<< UINT32 ArrayNum = 0; >>

D:"EFI_HII_REF"

N:StringIdentifier

{

OpenBracket I:Number CloseBracket << ArrayNum = _STOU32(I->getText()); >>

}

";" << _PCATCH(gCVfrVarDataTypeDB.DataTypeAddField (N->getText(), D->getText(), ArrayNum), N); >>

;

dataStructFieldUser :

<< UINT32 ArrayNum = 0; >>

T:StringIdentifier

N:StringIdentifier

{

OpenBracket I:Number CloseBracket << ArrayNum = _STOU32(I->getText()); >>

}

";" << _PCATCH(gCVfrVarDataTypeDB.DataTypeAddField (N->getText(), T->getText(), ArrayNum), T); >>

;

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());

>>

;

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());

>>

(

OpenBrace guidSubDefinition[Guid] CloseBrace

| guidSubDefinition[Guid]

)

CloseBrace

;

vfrFormSetDefinition :

<<

EFI_GUID Guid;

EFI_GUID DefaultClassGuid = EFI_HII_PLATFORM_SETUP_FORMSET_GUID;

EFI_GUID ClassGuid1, ClassGuid2, ClassGuid3;

UINT8 ClassGuidNum = 0;

CIfrFormSet *FSObj = NULL;

UINT16 C, SC;

>>

L:FormSet

Uuid "=" guidDefinition[Guid] ","

Title "=" "STRING_TOKEN" "\(" S1:Number "\)" ","

Help "=" "STRING_TOKEN" "\(" S2:Number "\)" ","

{

ClassGuid "=" guidDefinition[ClassGuid1] << ++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:

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:

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:

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;

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);

FSObj->SetGuid (&Guid);

//

// for framework vfr to store formset guid used by varstore and efivarstore

//

if (mCompatibleMode) {

memcpy (&mFormsetGuid, &Guid, sizeof (EFI_GUID));

}

FSObj->SetFormSetTitle (_STOSID(S1->getText()));

FSObj->SetHelp (_STOSID(S2->getText()));

>>

{

FC:Class "=" classDefinition[C] "," << {CIfrClass CObj;SET_LINE_INFO (CObj, FC); CObj.SetClass(C);} >>

}

{

FSC:Subclass "=" subclassDefinition[SC] "," << {CIfrSubClass SCObj; SET_LINE_INFO (SCObj, FSC); SCObj.SetSubClass(SC);} >>

}

<<

_DeclareStandardDefaultStorage (GET_LINENO (L));

>>

vfrFormSetList

E:EndFormSet <<

if (mCompatibleMode) {

//

// declare all undefined varstore and efivarstore

//

_DeclareDefaultFrameworkVarStore (GET_LINENO(E));

}

CRT_END_OP (E); if (FSObj != NULL) delete FSObj;

>>

";"

;

vfrFormSetList :

(

vfrFormDefinition |

vfrFormMapDefinition |

vfrStatementImage |

vfrStatementVarStoreLinear |

vfrStatementVarStoreEfi |

vfrStatementVarStoreNameValue |

vfrStatementDefaultStore |

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 <<ArrayNum = _STOU32(AN1->getText());>>}

<< TypeName = U64->getText(); LineNum = U64->getLine(); >>

| U32:"UINT32" {OpenBracket AN2:Number CloseBracket <<ArrayNum = _STOU32(AN2->getText());>>}

<< TypeName = U32->getText(); LineNum = U32->getLine(); >>

| U16:"UINT16" {OpenBracket AN3:Number CloseBracket <<ArrayNum = _STOU32(AN3->getText());>>}

<< TypeName = U16->getText(); LineNum = U16->getLine(); >>

| U8:"UINT8" {OpenBracket AN4:Number CloseBracket <<ArrayNum = _STOU32(AN4->getText());>>}

<< TypeName = U8->getText(); LineNum = U8->getLine(); >>

| BL:"BOOLEAN" {OpenBracket AN5:Number CloseBracket <<ArrayNum = _STOU32(AN5->getText());>>}

<< TypeName = BL->getText(); LineNum = BL->getLine(); >>

| SI:"EFI_STRING_ID" {OpenBracket AN6:Number CloseBracket <<ArrayNum = _STOU32(AN6->getText());>>}

<< TypeName = SI->getText(); LineNum = SI->getLine(); >>

| D:"EFI_HII_DATE" {OpenBracket AN7:Number CloseBracket <<ArrayNum = _STOU32(AN7->getText());>>}

<< TypeName = D->getText(); LineNum = D->getLine(); IsStruct = TRUE;>>

| T:"EFI_HII_TIME" {OpenBracket AN8:Number CloseBracket <<ArrayNum = _STOU32(AN8->getText());>>}

<< TypeName = T->getText(); LineNum = T->getLine(); IsStruct = TRUE;>>

| R:"EFI_HII_REF" {OpenBracket AN9:Number CloseBracket <<ArrayNum = _STOU32(AN9->getText());>>}

<< TypeName = R->getText(); LineNum = R->getLine(); IsStruct = TRUE;>>

| TN:StringIdentifier {OpenBracket AN10:Number CloseBracket <<ArrayNum = _STOU32(AN10->getText());>>}

<< 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;

>>

(

("," "data" {OpenBracket IDX1:Number CloseBracket <<IsArray = TRUE;>>}

<<

ArrayIdx = 0;

if (IsArray == TRUE) {

ArrayIdx = _STOU8(IDX1->getText());

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());

memcpy (ByteOffset, &Data_U64, TypeSize);

}else if (strcmp ("UINT32", TypeName) == 0) {

Data_U32 = _STOU32(RD->getText());

memcpy (ByteOffset, &Data_U32, TypeSize);

}else if (strcmp ("UINT16", TypeName) == 0) {

Data_U16 = _STOU16(RD->getText());

memcpy (ByteOffset, &Data_U16, TypeSize);

}else if (strcmp ("UINT8", TypeName) == 0) {

Data_U8 = _STOU8(RD->getText());

memcpy (ByteOffset, &Data_U8, TypeSize);

}else if (strcmp ("BOOLEAN", TypeName)== 0) {

Data_BL = _STOU8(RD->getText());

memcpy (ByteOffset, &Data_BL, TypeSize);

}else if (strcmp ("EFI_STRING_ID", TypeName) == 0) {

Data_SID = _STOSID(RD->getText());

memcpy (ByteOffset, &Data_SID, TypeSize);

}

} else {

gCVfrVarDataTypeDB.GetDataFieldInfo(TFName, FieldOffset, FieldType, FieldSize);

switch (FieldType) {

case EFI_IFR_TYPE_NUM_SIZE_8:

Data_U8 = _STOU8(RD->getText());

memcpy (ByteOffset + FieldOffset, &Data_U8, FieldSize);

break;

case EFI_IFR_TYPE_NUM_SIZE_16:

Data_U16 = _STOU16(RD->getText());

memcpy (ByteOffset + FieldOffset, &Data_U16, FieldSize);

break;

case EFI_IFR_TYPE_NUM_SIZE_32:

Data_U32 = _STOU32(RD->getText());

memcpy (ByteOffset + FieldOffset, &Data_U32, FieldSize);

break;

case EFI_IFR_TYPE_NUM_SIZE_64:

Data_U64 = _STOU64(RD->getText());

memcpy (ByteOffset + FieldOffset, &Data_U64, FieldSize);

break;

case EFI_IFR_TYPE_BOOLEAN:

Data_BL = _STOU8(RD->getText());

memcpy (ByteOffset + FieldOffset, &Data_BL, FieldSize);

break;

case EFI_IFR_TYPE_STRING:

Data_SID = _STOSID(RD->getText());

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()); >>

}

<<

if (mCVfrDefaultStore.DefaultIdRegistered (DefaultId) == FALSE) {

CIfrDefaultStore DSObj;

_PCATCH(mCVfrDefaultStore.RegisterDefaultStore (DSObj.GetObjBinAddr(), N->getText(), _STOSID(S->getText()), DefaultId)), D->getLine();

DSObj.SetLineNo(D->getLine());

DSObj.SetDefaultName (_STOSID(S->getText()));

DSObj.SetDefaultId (DefaultId);

} else {

_PCATCH(mCVfrDefaultStore.ReRegisterDefaultStoreById (DefaultId, N->getText(), _STOSID(S->getText()))), D->getLine();

}

>>

";"

;

vfrStatementVarStoreLinear :

<<

EFI_GUID Guid;

CIfrVarStore VSObj;

CHAR8 *TypeName;

CHAR8 *StoreName;

UINT32 LineNum;

EFI_VARSTORE_ID VarStoreId = EFI_VARSTORE_ID_INVALID;

UINT32 Size;

>>

V:Varstore << VSObj.SetLineNo(V->getLine()); >>

(

TN:StringIdentifier "," << TypeName = TN->getText(); LineNum = TN->getLine(); >>

| 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());

}

>>

}

{

VarId "=" ID:Number "," <<

_PCATCH(

(INTN)(VarStoreId = _STOU16(ID->getText())) != 0,

(INTN)TRUE,

ID,

"varid 0 is not allowed."

);

>>

}

Name "=" SN:StringIdentifier ","

Uuid "=" guidDefinition[Guid]

<<

if (mCompatibleMode) {

StoreName = TypeName;

} else {

StoreName = SN->getText();

}

_PCATCH(mCVfrDataStorage.DeclareBufferVarStore (

StoreName,

&Guid,

&gCVfrVarDataTypeDB,

TypeName,

VarStoreId

), LineNum);

VSObj.SetGuid (&Guid);

_PCATCH(mCVfrDataStorage.GetVarStoreId(StoreName, &VarStoreId), SN);

VSObj.SetVarStoreId (VarStoreId);

_PCATCH(gCVfrVarDataTypeDB.GetDataTypeSize(TypeName, &Size), LineNum);

VSObj.SetSize ((UINT16) Size);

VSObj.SetName (SN->getText());

>>

";"

;

vfrStatementVarStoreEfi :

<<

BOOLEAN IsUEFI23EfiVarstore = TRUE;

EFI_GUID Guid;

CIfrVarStoreEfi VSEObj;

EFI_VARSTORE_ID VarStoreId = EFI_VARSTORE_ID_INVALID;

UINT32 Attr = 0;

UINT32 Size;

CHAR8 *TypeName;

UINT32 LineNum;

CHAR8 *StoreName = NULL;

>>

E:Efivarstore << VSEObj.SetLineNo(E->getLine()); >>

(

TN:StringIdentifier "," << TypeName = TN->getText(); LineNum = TN->getLine(); >>

| 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())) != 0,

(INTN)TRUE,

ID,

"varid 0 is not allowed."

);

>>

}

Attribute "=" vfrVarStoreEfiAttr[Attr] ( "\|" vfrVarStoreEfiAttr[Attr] )* ","

<< VSEObj.SetAttributes (Attr); >>

(

Name "=" SN:StringIdentifier "," << StoreName = SN->getText(); >>

|

Name "=" "STRING_TOKEN" "\(" VN:Number "\)" ","

VarSize "=" N:Number "," <<

IsUEFI23EfiVarstore = FALSE;

StoreName = gCVfrStringDB.GetVarStoreNameFormStringId(_STOSID(VN->getText()));

if (StoreName == NULL) {

_PCATCH (VFR_RETURN_UNSUPPORTED, VN->getLine(), "Can't get varstore name for this StringId!");

}

Size = _STOU32(N->getText());

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(mCVfrDataStorage.DeclareBufferVarStore (

StoreName,

&Guid,

&gCVfrVarDataTypeDB,

TypeName,

VarStoreId

), LineNum);

_PCATCH(mCVfrDataStorage.GetVarStoreId(StoreName, &VarStoreId), SN);

_PCATCH(gCVfrVarDataTypeDB.GetDataTypeSize(TypeName, &Size), LineNum);

} else {

_PCATCH(mCVfrDataStorage.DeclareBufferVarStore (

TN->getText(),

&Guid,

&gCVfrVarDataTypeDB,

TypeName,

VarStoreId

), LineNum);

_PCATCH(mCVfrDataStorage.GetVarStoreId(TN->getText(), &VarStoreId), VN);

_PCATCH(gCVfrVarDataTypeDB.GetDataTypeSize(TypeName, &Size), N->getLine());

}

VSEObj.SetGuid (&Guid);

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()); >>

;

vfrStatementVarStoreNameValue :

<<

EFI_GUID Guid;

CIfrVarStoreNameValue VSNVObj;

EFI_VARSTORE_ID VarStoreId;

>>

L:NameValueVarStore << VSNVObj.SetLineNo(L->getLine()); >>

SN:StringIdentifier "," << _PCATCH(mCVfrDataStorage.DeclareNameVarStoreBegin (SN->getText()), SN); >>

(

Name "=" "STRING_TOKEN" "\(" N:Number "\)" "," << _PCATCH(mCVfrDataStorage.NameTableAddItem (_STOSID(N->getText())), SN); >>

)+

Uuid "=" guidDefinition[Guid] << _PCATCH(mCVfrDataStorage.DeclareNameVarStoreEnd (&Guid), SN); >>

<<

VSNVObj.SetGuid (&Guid);

_PCATCH(mCVfrDataStorage.GetVarStoreId(SN->getText(), &VarStoreId), SN);

VSNVObj.SetVarStoreId (VarStoreId);

>>

";"

;

classDefinition[UINT16 & Class] :

<< $Class = 0; >>

validClassNames[$Class] ( "\|" validClassNames[$Class] )*

;

validClassNames[UINT16 & Class] :

ClassNonDevice << $Class |= EFI_NON_DEVICE_CLASS; >>

| ClassDiskDevice << $Class |= EFI_DISK_DEVICE_CLASS; >>

| ClassVideoDevice << $Class |= EFI_VIDEO_DEVICE_CLASS; >>

| ClassNetworkDevice << $Class |= EFI_NETWORK_DEVICE_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()); >>

;

subclassDefinition[UINT16 & SubClass] :

<< $SubClass = 0; >>

SubclassSetupApplication << $SubClass |= EFI_SETUP_APPLICATION_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()); >>

;

vfrStatementDisableIfFormSet :

<<

CIfrDisableIf DIObj;

mConstantOnlyInExpression = TRUE;

>>

D:DisableIf << DIObj.SetLineNo(D->getLine()); >>

vfrStatementExpression[0] ";" << mConstantOnlyInExpression = FALSE; >>

vfrFormSetList

E:EndIf << CRT_END_OP (E); >>

";"

;

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); >>

;

vfrStatementHeader[CIfrStatementHeader *SHObj] :

Prompt "=" "STRING_TOKEN" "\(" S1:Number "\)" "," << $SHObj->SetPrompt (_STOSID(S1->getText())); >>

Help "=" "STRING_TOKEN" "\(" S2:Number "\)" << $SHObj->SetHelp (_STOSID(S2->getText())); >>

;

vfrQuestionHeader[CIfrQuestionHeader & QHObj, EFI_QUESION_TYPE QType = QUESTION_NORMAL]:

<<

EFI_VARSTORE_INFO Info;

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;

case QUESTION_REF:

//

// VarIdStr != NULL stand for question with storagae.

//

if (VarIdStr != NULL) {

mCVfrQuestionDB.RegisterRefQuestion (QName, VarIdStr, QId);

} else {

mCVfrQuestionDB.RegisterQuestion (QName, NULL, QId);

}

break;

default:

_PCATCH(VFR_RETURN_FATAL_ERROR);

}

$QHObj.SetQuestionId (QId);

if (VarIdStr != NULL) {

$QHObj.SetVarStoreInfo (&Info);

}

>>

vfrStatementHeader[&$QHObj]

<<

if (VarIdStr != NULL) {

delete VarIdStr;

_SAVE_CURRQEST_VARINFO (Info);

}

>>

;

questionheaderFlagsField[UINT8 & Flags] :

ReadOnlyFlag << $Flags |= 0x01; >>

| InteractiveFlag << $Flags |= 0x04; >>

| ResetRequiredFlag << $Flags |= 0x10; >>

| OptionOnlyFlag << $Flags |= 0x80; >>

| NVAccessFlag

| LateCheckFlag

;

vfrStorageVarId[EFI_VARSTORE_INFO & Info, CHAR8 *&QuestVarIdStr, BOOLEAN CheckFlag = TRUE] :

<<

UINT32 Idx;

UINT32 LineNo;

EFI_VFR_VARSTORE_TYPE VarStoreType = EFI_VFR_VARSTORE_INVALID;

CHAR8 *VarIdStr = NULL;

CHAR8 *VarStr = NULL;

CHAR8 *SName = NULL;

CHAR8 *TName = NULL;

EFI_VFR_RETURN_CODE VfrReturnCode = VFR_RETURN_SUCCESS;

EFI_IFR_TYPE_VALUE Dummy = gZeroEfiIfrTypeValue;

>>

(

SN1:StringIdentifier << SName = SN1->getText(); _STRCAT(&VarIdStr, SN1->getText()); >>

OpenBracket I1:Number CloseBracket <<

Idx = _STOU32(I1->getText());

_STRCAT(&VarIdStr, "[");

_STRCAT(&VarIdStr, I1->getText());

_STRCAT(&VarIdStr, "]");

>>

<<

VfrReturnCode = mCVfrDataStorage.GetVarStoreType (SName, VarStoreType);

if (mCompatibleMode && VfrReturnCode == VFR_RETURN_UNDEFINED) {

mCVfrDataStorage.DeclareBufferVarStore (

SName,

&mFormsetGuid,

&gCVfrVarDataTypeDB,

SName,

EFI_VARSTORE_ID_INVALID,

FALSE

);

VfrReturnCode = mCVfrDataStorage.GetVarStoreType (SName, VarStoreType);

}

if (CheckFlag || VfrReturnCode == VFR_RETURN_SUCCESS) {

_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);

if (mCompatibleMode && VfrReturnCode == VFR_RETURN_UNDEFINED) {

mCVfrDataStorage.DeclareBufferVarStore (

SName,

&mFormsetGuid,

&gCVfrVarDataTypeDB,

SName,

EFI_VARSTORE_ID_INVALID,

FALSE

);

VfrReturnCode = mCVfrDataStorage.GetVarStoreType (SName, VarStoreType);

}

if (CheckFlag || VfrReturnCode == VFR_RETURN_SUCCESS) {

_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(((VarStoreType != EFI_VFR_VARSTORE_BUFFER) ? 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());

if (mCompatibleMode) Idx --;

if (Idx > 0) {

//

// Idx == 0, [0] can be ignored.

// Array[0] is same to Array for unify the varid name to cover [0]

//

_STRCAT(&VarIdStr, "[");

_STRCAT(&VarIdStr, I2->getText());

_STRCAT(&VarIdStr, "]");

}

_STRCAT(&VarStr, "[");

_STRCAT(&VarStr, I2->getText());

_STRCAT(&VarStr, "]");

>>

}

)* <<

switch (VarStoreType) {

case EFI_VFR_VARSTORE_EFI:

_PCATCH(mCVfrDataStorage.GetEfiVarStoreInfo (&$Info), SN2);

break;

case EFI_VFR_VARSTORE_BUFFER:

_PCATCH(gCVfrVarDataTypeDB.GetDataFieldInfo (VarStr, $Info.mInfo.mVarOffset, $Info.mVarType, $Info.mVarTotalSize), SN2->getLine(), VarStr);

_PCATCH((EFI_VFR_RETURN_CODE)gCVfrBufferConfig.Register (

SName,

NULL),

SN2->getLine());

_PCATCH((EFI_VFR_RETURN_CODE)gCVfrBufferConfig.Write (

'a',

SName,

NULL,

$Info.mVarType,

$Info.mInfo.mVarOffset,

$Info.mVarTotalSize,

Dummy),

SN2->getLine());

break;

case EFI_VFR_VARSTORE_NAME:

default: break;

}

QuestVarIdStr = VarIdStr;

if (VarStr != NULL) {delete VarStr;}

>>

)

;

vfrQuestionDataFieldName [EFI_QUESTION_ID &QId, UINT32 &Mask, CHAR8 *&VarIdStr, UINT32 &LineNo] :

<<

UINT32 Idx;

VarIdStr = NULL; LineNo = 0;

>>

(

SN1:StringIdentifier << _STRCAT(&VarIdStr, SN1->getText()); LineNo = SN1->getLine(); >>

OpenBracket I1:Number CloseBracket <<

_STRCAT(&VarIdStr, "[");

_STRCAT(&VarIdStr, I1->getText());

_STRCAT(&VarIdStr, "]");

mCVfrQuestionDB.GetQuestionId (NULL, VarIdStr, $QId, $Mask);

if (mConstantOnlyInExpression) {

_PCATCH(VFR_RETURN_CONSTANT_ONLY, LineNo);

}

>>

)

|

(

SN2:StringIdentifier << _STRCAT (&VarIdStr, SN2->getText()); LineNo = SN2->getLine(); >>

(

"." <<

_STRCAT (&VarIdStr, ".");

if (mConstantOnlyInExpression) {

_PCATCH(VFR_RETURN_CONSTANT_ONLY, LineNo);

}

>>

SF:StringIdentifier << _STRCAT (&VarIdStr, SF->getText()); >>

{

OpenBracket I2:Number CloseBracket <<

Idx = _STOU32(I2->getText());

if (mCompatibleMode) Idx --;

if (Idx > 0) {

//

// Idx == 0, [0] can be ignored.

// Array[0] is same to Array

//

_STRCAT(&VarIdStr, "[");

_STRCAT(&VarIdStr, I2->getText());

_STRCAT(&VarIdStr, "]");

}

>>

}

)*

<< mCVfrQuestionDB.GetQuestionId (NULL, VarIdStr, $QId, $Mask); >>

)

;

vfrConstantValueField[UINT8 Type] > [EFI_IFR_TYPE_VALUE Value] :

<<

EFI_GUID Guid;

>>

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 :

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()); >>

| QI:Number";" FI:Number";" guidDefinition[Guid] ";" "STRING_TOKEN" "\(" DP:Number "\)"

<< $Value.ref = _STOR(QI->getText(), FI->getText(), &Guid, DP->getText()); >>

| "STRING_TOKEN" "\(" S1:Number "\)" << $Value.string = _STOSID(S1->getText()); >>

;

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())); >>

(

vfrStatementImage |

vfrStatementLocked |

vfrStatementRules |

vfrStatementDefault |

vfrStatementStat |

vfrStatementQuestions |

vfrStatementConditional |

vfrStatementLabel |

vfrStatementBanner |

// Just for framework vfr compatibility

vfrStatementInvalid |

vfrStatementExtension |

vfrStatementModal

)*

E:EndForm <<

if (mCompatibleMode) {

//

// Add Label for Framework Vfr

//

CIfrLabel LObj1;

LObj1.SetLineNo(E->getLine());

LObj1.SetNumber (0xffff); //add end label for UEFI, label number hardcode 0xffff

CIfrLabel LObj2;

LObj2.SetLineNo(E->getLine());

LObj2.SetNumber (0x0); //add dummy label for UEFI, label number hardcode 0x0

CIfrLabel LObj3;

LObj3.SetLineNo(E->getLine());

LObj3.SetNumber (0xffff); //add end label for UEFI, label number hardcode 0xffff

}

//

// Declare undefined Question so that they can be used in expression.

//

if (gCFormPkg.HavePendingUnassigned()) {

gCFormPkg.DeclarePendingQuestion (

gCVfrVarDataTypeDB,

mCVfrDataStorage,

mCVfrQuestionDB,

&mFormsetGuid,

E->getLine()

);

}

//

// mCVfrQuestionDB.PrintAllQuestion();

//

CRT_END_OP (E);

>>

";"

;

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); >>

(

MapTitle "=" "STRING_TOKEN" "\(" S2:Number "\)" ";"

MapGuid "=" guidDefinition[Guid] ";" << FMapObj->SetFormMapMethod (_STOFID(S2->getText()), &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

)*

E:EndForm << CRT_END_OP (E); >>

";"

;

vfrStatementRules :

<< CIfrRule RObj; >>

R:Rule << RObj.SetLineNo(R->getLine()); >>

S1:StringIdentifier "," <<

mCVfrRulesDB.RegisterRule (S1->getText());

RObj.SetRuleId (mCVfrRulesDB.GetRuleId(S1->getText()));

>>

vfrStatementExpression[0]

E:EndRule << CRT_END_OP (E); >>

";"

;

vfrStatementDefault :

<<

BOOLEAN IsExp = FALSE;

EFI_IFR_TYPE_VALUE Val = gZeroEfiIfrTypeValue;

CIfrDefault DObj;

EFI_DEFAULT_ID DefaultId = EFI_HII_DEFAULT_CLASS_STANDARD;

CHAR8 *VarStoreName = NULL;

EFI_VFR_VARSTORE_TYPE VarStoreType = EFI_VFR_VARSTORE_INVALID;

>>

D:Default << DObj.SetLineNo(D->getLine()); >>

(

(

vfrStatementValue "," << IsExp = TRUE; DObj.SetScope (1); CIfrEnd EndObj1; EndObj1.SetLineNo(D->getLine()); >>

| "=" vfrConstantValueField[_GET_CURRQEST_DATATYPE()] > [Val] "," <<

if (gCurrentMinMaxData != NULL && gCurrentMinMaxData->IsNumericOpcode()) {

//check default value is valid for Numeric Opcode

if (Val.u64 < gCurrentMinMaxData->GetMinData(_GET_CURRQEST_DATATYPE()) || Val.u64 > gCurrentMinMaxData->GetMaxData(_GET_CURRQEST_DATATYPE())) {

_PCATCH (VFR_RETURN_INVALID_PARAMETER, D->getLine(), "Numeric default value must be between MinValue and MaxValue.");

}

}

DObj.SetType (_GET_CURRQEST_DATATYPE());

DObj.SetValue(Val);

>>

)

{

DefaultStore "=" SN:StringIdentifier "," << _PCATCH(mCVfrDefaultStore.GetDefaultId (SN->getText(), &DefaultId), SN); DObj.SetDefaultId (DefaultId); >>

}

<<

_PCATCH(mCVfrDataStorage.GetVarStoreName (_GET_CURRQEST_VARTINFO().mVarStoreId, &VarStoreName), D->getLine());

_PCATCH(mCVfrDataStorage.GetVarStoreType (VarStoreName, VarStoreType), D->getLine());

if ((IsExp == FALSE) && (VarStoreType == EFI_VFR_VARSTORE_BUFFER)) {

_PCATCH(mCVfrDefaultStore.BufferVarStoreAltConfigAdd (

DefaultId,

_GET_CURRQEST_VARTINFO(),

VarStoreName,

_GET_CURRQEST_DATATYPE (),

Val),

D->getLine()

);

}

>>

)

;

vfrStatementStat :

vfrStatementSubTitle |

vfrStatementStaticText |

vfrStatementCrossReference

;

vfrStatementQuestions :

vfrStatementBooleanType |

vfrStatementDate |

vfrStatementNumericType |

vfrStatementStringType |

vfrStatementOrderedList |

vfrStatementTime

;

vfrStatementConditional :

vfrStatementDisableIfStat |

vfrStatementSuppressIfStat | //enhance to be compatible for framework endif

vfrStatementGrayOutIfStat |

vfrStatementInconsistentIfStat //to be compatible for framework

;

vfrStatementConditionalNew :

vfrStatementDisableIfStat |

vfrStatementSuppressIfStatNew |

vfrStatementGrayOutIfStatNew |

vfrStatementInconsistentIfStat //to be compatible for framework

;

vfrStatementSuppressIfStat :

<<mCompatibleMode>>? vfrStatementSuppressIfStatOld

| vfrStatementSuppressIfStatNew

;

vfrStatementGrayOutIfStat :

<<mCompatibleMode>>? vfrStatementGrayOutIfStatOld

| vfrStatementGrayOutIfStatNew

;

vfrStatementInvalid :

(

vfrStatementInvalidHidden |

vfrStatementInvalidInventory |

vfrStatementInvalidSaveRestoreDefaults

)

<< _CRT_OP (TRUE); >>

;

flagsField :

Number | InteractiveFlag | ManufacturingFlag | DefaultFlag |

NVAccessFlag | ResetRequiredFlag | LateCheckFlag

;

vfrStatementValue :

<< CIfrValue VObj; >>

V:Value << VObj.SetLineNo(V->getLine()); >>

"=" 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())); >>

{

"," FLAGS "=" vfrSubtitleFlags[SObj]

}

{ vfrStatementStatTagList "," }

E:";" << CRT_END_OP (E); >>

;

vfrSubtitleFlags [CIfrSubtitle & SObj] :

<< UINT8 LFlags = 0; >>

subtitleFlagsField[LFlags] ( "\|" subtitleFlagsField[LFlags] )*

<< _PCATCH(SObj.SetFlags (LFlags)); >>

;

subtitleFlagsField [UINT8 & Flags] :

N:Number << $Flags |= _STOU8(N->getText()); >>

| "HORIZONTAL" << $Flags |= 0x01; >>

;

vfrStatementStaticText :

<<

UINT8 Flags = 0;

EFI_QUESTION_ID QId = EFI_QUESTION_ID_INVALID;

EFI_STRING_ID TxtTwo = EFI_STRING_ID_INVALID;

>>

T:Text

Help "=" "STRING_TOKEN" "\(" S1:Number "\)" ","

Text "=" "STRING_TOKEN" "\(" S2:Number "\)"

{

"," Text "=" "STRING_TOKEN" "\(" S3:Number "\)" << TxtTwo = _STOSID(S3->getText()); >>

}

{

"," F:FLAGS "=" staticTextFlagsField[Flags] ( "\|" staticTextFlagsField[Flags] )*

"," Key "=" KN:Number

}

<<

if (Flags & EFI_IFR_FLAG_CALLBACK) {

CIfrAction AObj;

mCVfrQuestionDB.RegisterQuestion (NULL, NULL, QId);

AObj.SetLineNo (F->getLine());

AObj.SetQuestionId (QId);

AObj.SetPrompt (_STOSID(S2->getText()));

AObj.SetHelp (_STOSID(S1->getText()));

_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.SetTextTwo (TxtTwo);

}

>>

{ "," vfrStatementStatTagList }

";"

;

staticTextFlagsField[UINT8 & HFlags] :

N:Number << _PCATCH(_STOU8(N->getText()) == 0 ? VFR_RETURN_SUCCESS : VFR_RETURN_UNSUPPORTED, N->getLine()); >>

| questionheaderFlagsField[HFlags]

;

vfrStatementCrossReference :

vfrStatementGoto |

vfrStatementResetButton

;

vfrStatementGoto :

<<

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] ","

FormId "=" F1:Number ","

Question "=" QN1:Number ","

<<

RefType = 4;

DevPath = _STOSID(P->getText());

FId = _STOFID(F1->getText());

QId = _STOQID(QN1->getText());

>>

)

|

(

FormSetGuid "=" guidDefinition[FSId] ","

FormId "=" F2:Number ","

Question "=" QN2:Number ","

<<

RefType = 3;

FId = _STOFID(F2->getText());

QId = _STOQID(QN2->getText());

>>

)

|

(

FormId "=" F3:Number "," << RefType = 2; FId = _STOFID(F3->getText()); >>

Question "="

(

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()); >>

)

)

|

(

F4:Number "," <<

RefType = 1;

FId = _STOFID(F4->getText());

>>

)

}

<<

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);

R4Obj->SetFormId (FId);

R4Obj->SetQuestionId (QId);

break;

}

case 3:

{

R3Obj = new CIfrRef3;

QHObj = R3Obj;

OHObj = R3Obj;

R3Obj->SetLineNo(G->getLine());

R3Obj->SetFormSetId (FSId);

R3Obj->SetFormId (FId);

R3Obj->SetQuestionId (QId);

break;

}

case 2:

{

R2Obj = new CIfrRef2;

QHObj = R2Obj;

OHObj = R2Obj;

R2Obj->SetLineNo(G->getLine());

R2Obj->SetFormId (FId);

R2Obj->SetQuestionId (QId);

break;

}

case 1:

{

R1Obj = new CIfrRef;

QHObj = R1Obj;

OHObj = R1Obj;

R1Obj->SetLineNo(G->getLine());

R1Obj->SetFormId (FId);

break;

}

default: break;

}

>>

vfrQuestionHeader[*QHObj, QUESTION_REF]

{ "," F:FLAGS "=" vfrGotoFlags[QHObj, F->getLine()] }

{

"," Key "=" KN:Number << AssignQuestionKey (*QHObj, KN); >>

}

{

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] :

<< UINT8 HFlags = 0; >>

gotoFlagsField[HFlags] ( "\|" gotoFlagsField[HFlags] )*

<< _PCATCH(QHObj->SetFlags (HFlags), LineNum); >>

;

gotoFlagsField[UINT8 & HFlags] :

N:Number << _PCATCH(_STOU8(N->getText()) == 0 ? VFR_RETURN_SUCCESS : VFR_RETURN_UNSUPPORTED, N->getLine()); >>

| questionheaderFlagsField[HFlags]

;

getStringId :

"STRING_TOKEN" "\("

IdVal:Number

"\)"

;

vfrStatementResetButton :

<<

CIfrResetButton RBObj;

UINT16 DefaultId;

>>

L:ResetButton << RBObj.SetLineNo(L->getLine()); >>

DefaultStore

"=" N:StringIdentifier "," <<

_PCATCH(mCVfrDefaultStore.GetDefaultId (N->getText(), &DefaultId), N->getLine());

RBObj.SetDefaultId (DefaultId);

>>

vfrStatementHeader[&RBObj] ","

{ vfrStatementStatTagList "," }

E:EndResetButton << CRT_END_OP (E); >>

";"

;

vfrStatementBooleanType :

vfrStatementCheckBox |

vfrStatementAction

;

vfrStatementCheckBox :

<<

CIfrCheckBox CBObj;

EFI_IFR_TYPE_VALUE Val = gZeroEfiIfrTypeValue;

CHAR8 *VarStoreName = NULL;

UINT32 DataTypeSize;

>>

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");

}

>>

{

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"

);

}

>>

}

{

Key "=" KN:Number "," << AssignQuestionKey (CBObj, KN); >>

}

vfrStatementQuestionOptionList

E:EndCheckBox << CRT_END_OP (E); >>

";"

;

vfrCheckBoxFlags [CIfrCheckBox & CBObj, UINT32 LineNum] :

<<

UINT8 LFlags = 0;

UINT8 HFlags = 0;

>>

checkboxFlagsField[LFlags, HFlags] ( "\|" checkboxFlagsField[LFlags, HFlags] )*

<< _PCATCH(CBObj.SetFlags (HFlags, LFlags), LineNum); >>

;

checkboxFlagsField[UINT8 & LFlags, UINT8 & HFlags] :

N:Number <<

if (mCompatibleMode) {

//

// set question flag

//

$LFlags |= _STOU8(N->getText());

} else {

_PCATCH(_STOU8(N->getText()) == 0 ? VFR_RETURN_SUCCESS : VFR_RETURN_UNSUPPORTED, N->getLine());

}

>>

| D:"DEFAULT" <<

if (mCompatibleMode) {

//

// set question Default flag

//

$LFlags |= 0x01;

} else {

_PCATCH (VFR_RETURN_UNSUPPORTED, D);

}

>>

| M:"MANUFACTURING" <<

if (mCompatibleMode) {

//

// set question MFG flag

//

$LFlags |= 0x02;

} else {

_PCATCH (VFR_RETURN_UNSUPPORTED, M);

}

>>

| "CHECKBOX_DEFAULT" << $LFlags |= 0x01; >>

| "CHECKBOX_DEFAULT_MFG" << $LFlags |= 0x02; >>

| questionheaderFlagsField[HFlags]

;

vfrStatementAction :

<< CIfrAction AObj; >>

L:Action << AObj.SetLineNo(L->getLine()); >>

vfrQuestionHeader[AObj] ","

{ F:FLAGS "=" vfrActionFlags[AObj, F->getLine()] "," }

Config "=" "STRING_TOKEN" "\(" S:Number "\)" "," << AObj.SetQuestionConfig (_STOSID(S->getText())); >>

vfrStatementQuestionTagList

E:EndAction << CRT_END_OP (E); >>

";"

;

vfrActionFlags[CIfrAction & AObj, UINT32 LineNum] :

<< UINT8 HFlags = 0; >>

actionFlagsField[HFlags] ( "\|" actionFlagsField[HFlags] )*

<< _PCATCH(AObj.SetFlags (HFlags), LineNum); >>

;

actionFlagsField[UINT8 & HFlags] :

N:Number << _PCATCH(_STOU8(N->getText()) == 0 ? VFR_RETURN_SUCCESS : VFR_RETURN_UNSUPPORTED, N->getLine()); >>

| questionheaderFlagsField[HFlags]

;

vfrStatementDate :

<<

EFI_QUESTION_ID QId = EFI_QUESTION_ID_INVALID;

CHAR8 *VarIdStr[3] = {NULL, };

CIfrDate DObj;

EFI_IFR_TYPE_VALUE Val = gZeroEfiIfrTypeValue;

>>

L:Date << DObj.SetLineNo(L->getLine()); >>

(

(

vfrQuestionHeader[DObj, QUESTION_DATE] ","

{ F:FLAGS "=" vfrDateFlags[DObj, F->getLine()] "," }

vfrStatementQuestionOptionList

)

|

(

Year VarId "=" D1:StringIdentifier "." D1Y:StringIdentifier ","

<< _STRCAT(&VarIdStr[0], D1->getText()); _STRCAT(&VarIdStr[0], "."); _STRCAT(&VarIdStr[0], D1Y->getText()); >>

Prompt "=" "STRING_TOKEN" "\(" YP:Number "\)" ","

Help "=" "STRING_TOKEN" "\(" YH:Number "\)" ","

minMaxDateStepDefault[Val.date, 0]

Month VarId "=" D2:StringIdentifier "." D2M:StringIdentifier ","

<< _STRCAT(&VarIdStr[1], D2->getText()); _STRCAT(&VarIdStr[1], "."); _STRCAT(&VarIdStr[1], D2M->getText()); >>

Prompt "=" "STRING_TOKEN" "\(" MP:Number "\)" ","

Help "=" "STRING_TOKEN" "\(" MH:Number "\)" ","

minMaxDateStepDefault[Val.date, 1]

Day VarId "=" D3:StringIdentifier "." D3D:StringIdentifier ","

<< _STRCAT(&VarIdStr[2], D3->getText()); _STRCAT(&VarIdStr[2], "."); _STRCAT(&VarIdStr[2], D3D->getText()); >>

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()));

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());} >>

)

( vfrStatementInconsistentIf )*

)

E:EndDate << CRT_END_OP (E); >>

";"

;

minMaxDateStepDefault[EFI_HII_DATE & D, UINT8 KeyValue] :

Minimum "=" MinN:Number ","

Maximum "=" MaxN:Number ","

{ "step" "=" Number "," }

{

"default" "=" N:Number "," <<

switch (KeyValue) {

case 0:

D.Year = _STOU16(N->getText());

if (D.Year < _STOU16 (MinN->getText()) || D.Year > _STOU16 (MaxN->getText())) {

_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());

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());

if (D.Day < 1 || D.Day > 31) {

_PCATCH (VFR_RETURN_INVALID_PARAMETER, N->getLine(), "Day default value must be between 1 and 31.");

}

break;

}

>>

}

;

vfrDateFlags [CIfrDate & DObj, UINT32 LineNum] :

<< UINT8 LFlags = 0; >>

dateFlagsField[LFlags] ( "\|" dateFlagsField[LFlags] )*

<< _PCATCH(DObj.SetFlags (EFI_IFR_QUESTION_FLAG_DEFAULT, LFlags), LineNum); >>

;

dateFlagsField [UINT8 & Flags] :

N:Number << $Flags |= _STOU8(N->getText()); >>

| "YEAR_SUPPRESS" << $Flags |= 0x01; >>

| "MONTH_SUPPRESS" << $Flags |= 0x02; >>

| "DAY_SUPPRESS" << $Flags |= 0x04; >>

| "STORAGE_NORMAL" << $Flags |= 0x00; >>

| "STORAGE_TIME" << $Flags |= 0x10; >>

| "STORAGE_WAKEUP" << $Flags |= 0x20; >>

;

vfrStatementNumericType :

vfrStatementNumeric |

vfrStatementOneOf

;

vfrSetMinMaxStep[CIfrMinMaxStepData & MMSDObj] :

<<

UINT64 MaxU8 = 0, MinU8 = 0, StepU8 = 0;

UINT32 MaxU4 = 0, MinU4 = 0, StepU4 = 0;

UINT16 MaxU2 = 0, MinU2 = 0, StepU2 = 0;

UINT8 MaxU1 = 0, MinU1 = 0, StepU1 = 0;

>>

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;

}

>>

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");

}

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");

}

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");

}

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");

}

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;

}

>>

}

<<

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;

BOOLEAN IsSupported;

>>

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");

}

_PCATCH(NObj.SetFlags (NObj.FLAGS(), _GET_CURRQEST_DATATYPE()), L->getLine());

>>

{ F:FLAGS "=" vfrNumericFlags[NObj, F->getLine()] "," }

{

Key "=" KN:Number "," << AssignQuestionKey (NObj, KN); >>

}

vfrSetMinMaxStep[NObj]

vfrStatementQuestionOptionList

E:EndNumeric <<

IsSupported = FALSE;

switch (_GET_CURRQEST_DATATYPE()) {

case EFI_IFR_TYPE_NUM_SIZE_8:

case EFI_IFR_TYPE_NUM_SIZE_16:

case EFI_IFR_TYPE_NUM_SIZE_32:

case EFI_IFR_TYPE_NUM_SIZE_64:

IsSupported = TRUE;

break;

default:

break;

}

if (!IsSupported) {

_PCATCH (VFR_RETURN_INVALID_PARAMETER, L->getLine(), "Numeric question only support UINT8, UINT16, UINT32 and UINT64 data type.");

}

CRT_END_OP (E);

>>

";"

;

vfrNumericFlags [CIfrNumeric & NObj, UINT32 LineNum] :

<<

UINT8 LFlags = _GET_CURRQEST_DATATYPE() & EFI_IFR_NUMERIC_SIZE;

UINT8 HFlags = 0;

EFI_VFR_VARSTORE_TYPE VarStoreType = EFI_VFR_VARSTORE_INVALID;

>>

numericFlagsField[HFlags, LFlags] ( "\|" numericFlagsField[HFlags, LFlags] )*

<<

//check data type flag

VarStoreType = mCVfrDataStorage.GetVarStoreType (_GET_CURRQEST_VARTINFO().mVarStoreId);

if (VarStoreType == EFI_VFR_VARSTORE_BUFFER || VarStoreType == EFI_VFR_VARSTORE_EFI) {

if (_GET_CURRQEST_DATATYPE() != (LFlags & EFI_IFR_NUMERIC_SIZE)) {

_PCATCH(VFR_RETURN_INVALID_PARAMETER, LineNum, "Numeric Flag is not same to Numeric VarData type");

}

} else {

// update data type for name/value store

UINT32 DataTypeSize;

_GET_CURRQEST_VARTINFO().mVarType = LFlags & EFI_IFR_NUMERIC_SIZE;

gCVfrVarDataTypeDB.GetDataTypeSize (_GET_CURRQEST_DATATYPE(), &DataTypeSize);

_GET_CURRQEST_VARTINFO().mVarTotalSize = DataTypeSize;

}

_PCATCH(NObj.SetFlags (HFlags, LFlags), LineNum);

>>

;

numericFlagsField [UINT8 & HFlags, UINT8 & LFlags] :

N:Number << _PCATCH(_STOU8(N->getText()) == 0 ? VFR_RETURN_SUCCESS : VFR_RETURN_UNSUPPORTED, N->getLine()); >>

| "NUMERIC_SIZE_1" << $LFlags = ($LFlags & ~EFI_IFR_NUMERIC_SIZE) | EFI_IFR_NUMERIC_SIZE_1; >>

| "NUMERIC_SIZE_2" << $LFlags = ($LFlags & ~EFI_IFR_NUMERIC_SIZE) | EFI_IFR_NUMERIC_SIZE_2; >>

| "NUMERIC_SIZE_4" << $LFlags = ($LFlags & ~EFI_IFR_NUMERIC_SIZE) | EFI_IFR_NUMERIC_SIZE_4; >>

| "NUMERIC_SIZE_8" << $LFlags = ($LFlags & ~EFI_IFR_NUMERIC_SIZE) | EFI_IFR_NUMERIC_SIZE_8; >>

| "DISPLAY_INT_DEC" << $LFlags = ($LFlags & ~EFI_IFR_DISPLAY) | EFI_IFR_DISPLAY_INT_DEC; >>

| "DISPLAY_UINT_DEC" << $LFlags = ($LFlags & ~EFI_IFR_DISPLAY) | EFI_IFR_DISPLAY_UINT_DEC; >>

| "DISPLAY_UINT_HEX" << $LFlags = ($LFlags & ~EFI_IFR_DISPLAY) | EFI_IFR_DISPLAY_UINT_HEX; >>

| questionheaderFlagsField[HFlags]

;

vfrStatementOneOf :

<<

CIfrOneOf OObj;

UINT32 DataTypeSize;

BOOLEAN IsSupported;

>>

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");

}

_PCATCH(OObj.SetFlags (OObj.FLAGS(), _GET_CURRQEST_DATATYPE()), L->getLine());

>>

{ F:FLAGS "=" vfrOneofFlagsField[OObj, F->getLine()] "," }

{

vfrSetMinMaxStep[OObj]

}

vfrStatementQuestionOptionList

E:EndOneOf <<

IsSupported = FALSE;

switch (_GET_CURRQEST_DATATYPE()) {

case EFI_IFR_TYPE_NUM_SIZE_8:

case EFI_IFR_TYPE_NUM_SIZE_16:

case EFI_IFR_TYPE_NUM_SIZE_32:

case EFI_IFR_TYPE_NUM_SIZE_64:

IsSupported = TRUE;

break;

default:

break;

}

if (!IsSupported) {

_PCATCH (VFR_RETURN_INVALID_PARAMETER, L->getLine(), "OneOf question only support UINT8, UINT16, UINT32 and UINT64 data type.");

}

CRT_END_OP (E);

>>

";"

;

vfrOneofFlagsField [CIfrOneOf & OObj, UINT32 LineNum] :

<<

UINT8 LFlags = _GET_CURRQEST_DATATYPE() & EFI_IFR_NUMERIC_SIZE;

UINT8 HFlags = 0;

EFI_VFR_VARSTORE_TYPE VarStoreType = EFI_VFR_VARSTORE_INVALID;

>>

numericFlagsField[HFlags, LFlags] ( "\|" numericFlagsField[HFlags, LFlags] )*

<<

//check data type flag

VarStoreType = mCVfrDataStorage.GetVarStoreType (_GET_CURRQEST_VARTINFO().mVarStoreId);

if (VarStoreType == EFI_VFR_VARSTORE_BUFFER || VarStoreType == EFI_VFR_VARSTORE_EFI) {

if (_GET_CURRQEST_DATATYPE() != (LFlags & EFI_IFR_NUMERIC_SIZE)) {

_PCATCH(VFR_RETURN_INVALID_PARAMETER, LineNum, "Numeric Flag is not same to Numeric VarData type");

}

} else {

// update data type for Name/Value store

UINT32 DataTypeSize;

_GET_CURRQEST_VARTINFO().mVarType = LFlags & EFI_IFR_NUMERIC_SIZE;

gCVfrVarDataTypeDB.GetDataTypeSize (_GET_CURRQEST_DATATYPE(), &DataTypeSize);

_GET_CURRQEST_VARTINFO().mVarTotalSize = DataTypeSize;

}

_PCATCH(OObj.SetFlags (HFlags, LFlags), LineNum);

>>

;

vfrStatementStringType :

vfrStatementString |

vfrStatementPassword

;

vfrStatementString :

<<

CIfrString SObj;

UINT32 VarArraySize;

UINT8 StringMinSize;

UINT8 StringMaxSize;

>>

L:String << SObj.SetLineNo(L->getLine()); >>

vfrQuestionHeader[SObj] ","

{ F:FLAGS "=" vfrStringFlagsField[SObj, F->getLine()] "," }

{

Key "=" KN:Number "," << AssignQuestionKey (SObj, KN); >>

}

MinSize "=" MIN:Number "," <<

VarArraySize = _GET_CURRQEST_ARRAY_SIZE();

StringMinSize = _STOU8(MIN->getText());

if (_STOU64(MIN->getText()) > 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());

if (_STOU64(MAX->getText()) > 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); >>

";"

;

vfrStringFlagsField [CIfrString & SObj, UINT32 LineNum] :

<<

UINT8 LFlags = 0;

UINT8 HFlags = 0;

>>

stringFlagsField[HFlags, LFlags] ( "\|" stringFlagsField[HFlags, LFlags] )*

<< _PCATCH(SObj.SetFlags (HFlags, LFlags), LineNum); >>

;

stringFlagsField [UINT8 & HFlags, UINT8 & LFlags] :

N:Number << _PCATCH(_STOU8(N->getText()) == 0 ? VFR_RETURN_SUCCESS : VFR_RETURN_UNSUPPORTED, N->getLine()); >>

| "MULTI_LINE" << $LFlags = 0x01; >>

| questionheaderFlagsField[HFlags]

;

vfrStatementPassword :

<<

CIfrPassword PObj;

UINT32 VarArraySize;

UINT16 PasswordMinSize;

UINT16 PasswordMaxSize;

>>

L:Password << PObj.SetLineNo(L->getLine()); >>

vfrQuestionHeader[PObj] ","

{ F:FLAGS "=" vfrPasswordFlagsField[PObj, F->getLine()] "," }

{

Key "=" KN:Number "," << AssignQuestionKey (PObj, KN); >>

}

MinSize "=" MIN:Number "," <<

VarArraySize = _GET_CURRQEST_ARRAY_SIZE();

PasswordMinSize = _STOU16(MIN->getText());

if (_STOU64(MIN->getText()) > 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());

if (_STOU64(MAX->getText()) > 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) {