1/*++ @file 2Vfr Syntax 3 4Copyright (c) 2004 - 2014, Intel Corporation. All rights reserved.<BR> 5This program and the accompanying materials 6are licensed and made available under the terms and conditions of the BSD License 7which accompanies this distribution. The full text of the license may be found at 8http://opensource.org/licenses/bsd-license.php 9 10THE PROGRAM IS DISTRIBUTED UNDER THE BSD LICENSE ON AN "AS IS" BASIS, 11WITHOUT WARRANTIES OR REPRESENTATIONS OF ANY KIND, EITHER EXPRESS OR IMPLIED. 12 13--*/ 14 15#header<< 16 17#include "EfiVfr.h" 18#include "VfrFormPkg.h" 19#include "VfrError.h" 20#include "VfrUtilityLib.h" 21#include "AToken.h" 22#include "ATokPtr.h" 23>> 24 25<< 26#include "stdio.h" 27#include "PBlackBox.h" 28#include "DLexerBase.h" 29#include "VfrLexer.h" 30#include "AToken.h" 31 32#define GET_LINENO(Obj) ((Obj)->getLine()) 33#define SET_LINE_INFO(Obj, L) {(Obj).SetLineNo((L)->getLine());} while (0) 34#define CRT_END_OP(Obj) {CIfrEnd EObj; if (Obj != NULL) EObj.SetLineNo ((Obj)->getLine());} while (0) 35 36typedef ANTLRCommonToken ANTLRToken; 37 38class CVfrDLGLexer : public VfrLexer 39{ 40public: 41 CVfrDLGLexer (DLGFileInput *F) : VfrLexer (F) {}; 42 INT32 errstd (char *Text) 43 { 44 printf ("unrecognized input '%s'\n", Text); 45 } 46}; 47 48UINT8 49VfrParserStart ( 50 IN FILE *File, 51 IN INPUT_INFO_TO_SYNTAX *InputInfo 52 ) 53{ 54 ParserBlackBox<CVfrDLGLexer, EfiVfrParser, ANTLRToken> VfrParser(File); 55 VfrParser.parser()->SetCompatibleMode (InputInfo->CompatibleMode); 56 VfrParser.parser()->SetOverrideClassGuid (InputInfo->OverrideClassGuid); 57 return VfrParser.parser()->vfrProgram(); 58} 59>> 60 61// 62// Define a lexical class for parsing quoted strings. Basically 63// starts with a double quote, and ends with a double quote that 64// is not preceeded with a backslash. 65// 66#lexclass QUOTED_STRING 67#token TheString "~[\"]*\"" << mode (START); >> 68 69// 70// Define a lexclass for skipping over C++ style comments 71// 72#lexclass CPP_COMMENT 73#token "~[\n]*" << skip (); >> 74#token "\n" << skip (); mode (START); newline (); >> 75 76// 77// Standard lexclass is START 78// 79#lexclass START 80 81// 82// Find start of C++ style comments 83// 84#token "//" << skip (); mode (CPP_COMMENT); >> 85 86// 87// Skip whitespace 88// 89#token "[\ \t]" << skip (); >> 90 91// 92// Skip over newlines, but count them 93// 94#token "\n" << skip (); newline (); >> 95 96// 97// Skip over 'extern' in any included .H file 98// 99#token "extern" << skip (); mode (CPP_COMMENT); >> 100 101// 102// Tokens for the different keywords. Syntax is: 103// TokenName("ErrorMessageText") "TokenString" 104// where: 105// TokenName is the token name (must be capitalized) that is used in the rules 106// ErrorMessageText is the string the compiler emits when it detects a syntax error 107// TokenString is the actual matching string used in the user script 108// 109#token FormPkgType("formpkgtype") "formpkgtype" 110#token OpenBrace("{") "\{" 111#token CloseBrace("}") "\}" 112#token OpenParen("(") "\(" 113#token CloseParen(")") "\)" 114#token OpenBracket("[") "\[" 115#token CloseBracket("]") "\]" 116 117#token LineDefinition "#line\ [0-9]+\ \"~[\"]+\"[\ \t]*\n" << gCVfrErrorHandle.ParseFileScopeRecord (begexpr (), line ()); skip (); newline (); >> 118#token DevicePath("devicepath") "devicepath" 119#token FormSet("formset") "formset" 120#token FormSetId("formsetid") "formsetid" 121#token EndFormSet("endformset") "endformset" 122#token Title("title") "title" 123#token FormId("formid") "formid" 124#token OneOf("oneof") "oneof" 125#token EndOneOf("endoneof") "endoneof" 126#token Prompt("prompt") "prompt" 127#token OrderedList("orderedlist") "orderedlist" 128#token MaxContainers("maxcontainers") "maxcontainers" 129#token EndList("endlist") "endlist" 130#token EndForm("endform") "endform" 131#token Form("form") "form" 132#token FormMap("formmap") "formmap" 133#token MapTitle("maptitle") "maptitle" 134#token MapGuid("mapguid") "mapguid" 135#token Subtitle("subtitle") "subtitle" 136#token EndSubtitle("endsubtitle") "endsubtitle" 137#token Help("help") "help" 138#token Text("text") "text" 139#token Option("option") "option" 140#token FLAGS("flags") "flags" 141#token Date("date") "date" 142#token EndDate("enddate") "enddate" 143#token Year("year") "year" 144#token Month("month") "month" 145#token Day("day") "day" 146#token Time("time") "time" 147#token EndTime("endtime") "endtime" 148#token Hour("hour") "hour" 149#token Minute("minute") "minute" 150#token Second("second") "second" 151#token GrayOutIf("grayoutif") "grayoutif" 152#token Label("label") "label" 153#token Timeout("timeout") "timeout" 154#token Inventory("inventory") "inventory" 155#token NonNvDataMap("_NON_NV_DATA_MAP") "_NON_NV_DATA_MAP" 156#token Struct("struct") "struct" 157#token Boolean("BOOLEAN") "BOOLEAN" 158#token Uint64("UINT64") "UINT64" 159#token Uint32("UINT32") "UINT32" 160#token Uint16("UINT16") "UINT16" 161#token Char16("CHAR16") "CHAR16" 162#token Uint8("UINT8") "UINT8" 163#token Uuid("guid") "guid" 164#token CheckBox("checkbox") "checkbox" 165#token EndCheckBox("endcheckbox") "endcheckbox" 166#token Numeric("numeric") "numeric" 167#token EndNumeric("endnumeric") "endnumeric" 168#token Minimum("minimum") "minimum" 169#token Maximum("maximum") "maximum" 170#token STEP("step") "step" 171#token Default("default") "default" 172#token Password("password") "password" 173#token EndPassword("endpassword") "endpassword" 174#token String("string") "string" 175#token EndString("endstring") "endstring" 176#token MinSize("minsize") "minsize" 177#token MaxSize("maxsize") "maxsize" 178#token Encoding("encoding") "encoding" 179#token SuppressIf("suppressif") "suppressif" 180#token DisableIf("disableif") "disableif" 181#token Hidden("hidden") "hidden" 182#token Goto("goto") "goto" 183#token FormSetGuid("formsetguid") "formsetguid" 184#token InconsistentIf("inconsistentif") "inconsistentif" 185#token WarningIf("warningif") "warningif" 186#token NoSubmitIf("nosubmitif") "nosubmitif" 187#token EndIf("endif") "endif" 188#token Key("key") "key" 189#token DefaultFlag("DEFAULT") "DEFAULT" 190#token ManufacturingFlag("MANUFACTURING") "MANUFACTURING" 191#token InteractiveFlag("INTERACTIVE") "INTERACTIVE" 192#token NVAccessFlag("NV_ACCESS") "NV_ACCESS" 193#token ResetRequiredFlag("RESET_REQUIRED") "RESET_REQUIRED" 194#token LateCheckFlag("LATE_CHECK") "LATE_CHECK" 195#token ReadOnlyFlag("READ_ONLY") "READ_ONLY" 196#token OptionOnlyFlag("OPTIONS_ONLY") "OPTIONS_ONLY" 197#token Class("class") "class" 198#token Subclass("subclass") "subclass" 199#token ClassGuid("classguid") "classguid" 200#token TypeDef("typedef") "typedef" 201#token Restore("restore") "restore" 202#token Save("save") "save" 203#token Defaults("defaults") "defaults" 204#token Banner("banner") "banner" 205#token Align("align") "align" 206#token Left("left") "left" 207#token Right("right") "right" 208#token Center("center") "center" 209#token Line("line") "line" 210#token Name("name") "name" 211 212#token VarId("varid") "varid" 213#token Question("question") "question" 214#token QuestionId("questionid") "questionid" 215#token Image("image") "image" 216#token Locked("locked") "locked" 217#token Rule("rule") "rule" 218#token EndRule("endrule") "endrule" 219#token Value("value") "value" 220#token Read("read") "read" 221#token Write("write") "write" 222#token ResetButton("resetbutton") "resetbutton" 223#token EndResetButton("endresetbutton") "endresetbutton" 224#token DefaultStore("defaultstore") "defaultstore" 225#token Attribute("attribute") "attribute" 226#token Varstore("varstore") "varstore" 227#token Efivarstore("efivarstore") "efivarstore" 228#token VarSize("varsize") "varsize" 229#token NameValueVarStore("namevaluevarstore") "namevaluevarstore" 230#token Action("action") "action" 231#token Config("config") "config" 232#token EndAction("endaction") "endaction" 233#token Refresh("refresh") "refresh" 234#token Interval("interval") "interval" 235#token VarstoreDevice("varstoredevice") "varstoredevice" 236#token GuidOp("guidop") "guidop" 237#token EndGuidOp("endguidop") "endguidop" 238#token DataType("datatype") "datatype" 239#token Data("data") "data" 240#token Modal("modal") "modal" 241 242// 243// Define the class and subclass tokens 244// 245#token ClassNonDevice("NONDEVICE") "NON_DEVICE" 246#token ClassDiskDevice("DISK_DEVICE") "DISK_DEVICE" 247#token ClassVideoDevice("VIDEO_DEVICE") "VIDEO_DEVICE" 248#token ClassNetworkDevice("NETWORK_DEVICE") "NETWORK_DEVICE" 249#token ClassInputDevice("INPUT_DEVICE") "INPUT_DEVICE" 250#token ClassOnBoardDevice("ONBOARD_DEVICE") "ONBOARD_DEVICE" 251#token ClassOtherDevice("OTHER_DEVICE") "OTHER_DEVICE" 252 253#token SubclassSetupApplication("SETUP_APPLICATION") "SETUP_APPLICATION" 254#token SubclassGeneralApplication("GENERAL_APPLICATION") "GENERAL_APPLICATION" 255#token SubclassFrontPage("FRONT_PAGE") "FRONT_PAGE" 256#token SubclassSingleUse("SINGLE_USE") "SINGLE_USE" 257 258// 259// This is the overall definition of a VFR form definition script. 260// 261 262vfrProgram > [UINT8 Return] : 263 << 264 mParserStatus = 0; 265 mCIfrOpHdrIndex = 0; 266 mConstantOnlyInExpression = FALSE; 267 >> 268 ( 269 vfrPragmaPackDefinition 270 | vfrDataStructDefinition 271 )* 272 vfrFormSetDefinition 273 << $Return = mParserStatus; >> 274 ; 275 276pragmaPackShowDef : 277 L:"show" << gCVfrVarDataTypeDB.Pack (L->getLine(), VFR_PACK_SHOW); >> 278 ; 279 280pragmaPackStackDef : 281 << 282 UINT32 LineNum; 283 UINT8 PackAction; 284 CHAR8 *Identifier = NULL; 285 UINT32 PackNumber = DEFAULT_PACK_ALIGN; 286 >> 287 ( 288 L1:"push" << LineNum = L1->getLine(); PackAction = VFR_PACK_PUSH; >> 289 | L2:"pop" << LineNum = L2->getLine(); PackAction = VFR_PACK_POP; >> 290 ) 291 { 292 "," ID:StringIdentifier << Identifier = ID->getText(); >> 293 } 294 { 295 "," N:Number << PackAction |= VFR_PACK_ASSIGN; PackNumber = _STOU32(N->getText(), N->getLine()); >> 296 } 297 << gCVfrVarDataTypeDB.Pack (LineNum, PackAction, Identifier, PackNumber); >> 298 ; 299 300pragmaPackNumber : 301 << 302 UINT32 LineNum; 303 UINT32 PackNumber = DEFAULT_PACK_ALIGN; 304 >> 305 N:Number << LineNum = N->getLine(); PackNumber = _STOU32(N->getText(), N->getLine()); >> 306 << gCVfrVarDataTypeDB.Pack (LineNum, VFR_PACK_ASSIGN, NULL, PackNumber); >> 307 ; 308 309vfrPragmaPackDefinition : 310 "\#pragma" "pack" "\(" 311 { 312 pragmaPackShowDef 313 | pragmaPackStackDef 314 | pragmaPackNumber 315 } 316 "\)" 317 ; 318 319vfrDataStructDefinition : 320 { TypeDef } Struct << gCVfrVarDataTypeDB.DeclareDataTypeBegin (); >> 321 { NonNvDataMap } 322 { 323 N1:StringIdentifier << _PCATCH(gCVfrVarDataTypeDB.SetNewTypeName (N1->getText()), N1); >> 324 } 325 OpenBrace 326 vfrDataStructFields 327 CloseBrace 328 { 329 N2:StringIdentifier << _PCATCH(gCVfrVarDataTypeDB.SetNewTypeName (N2->getText()), N2); >> 330 } 331 ";" << gCVfrVarDataTypeDB.DeclareDataTypeEnd (); >> 332 ; 333 334vfrDataStructFields : 335 ( 336 dataStructField64 | 337 dataStructField32 | 338 dataStructField16 | 339 dataStructField8 | 340 dataStructFieldBool | 341 dataStructFieldString | 342 dataStructFieldDate | 343 dataStructFieldTime | 344 dataStructFieldRef | 345 dataStructFieldUser 346 )* 347 ; 348 349dataStructField64 : 350 << UINT32 ArrayNum = 0; >> 351 D:"UINT64" 352 N:StringIdentifier 353 { 354 OpenBracket I:Number CloseBracket << ArrayNum = _STOU32(I->getText(), I->getLine()); >> 355 } 356 ";" << _PCATCH(gCVfrVarDataTypeDB.DataTypeAddField (N->getText(), D->getText(), ArrayNum), N); >> 357 ; 358 359dataStructField32 : 360 << UINT32 ArrayNum = 0; >> 361 D:"UINT32" 362 N:StringIdentifier 363 { 364 OpenBracket I:Number CloseBracket << ArrayNum = _STOU32(I->getText(), I->getLine()); >> 365 } 366 ";" << _PCATCH(gCVfrVarDataTypeDB.DataTypeAddField (N->getText(), D->getText(), ArrayNum), N); >> 367 ; 368 369dataStructField16 : 370 << 371 UINT32 ArrayNum = 0; 372 >> 373 ("UINT16" | "CHAR16") 374 N:StringIdentifier 375 { 376 OpenBracket I:Number CloseBracket << ArrayNum = _STOU32(I->getText(), I->getLine()); >> 377 } 378 ";" << _PCATCH(gCVfrVarDataTypeDB.DataTypeAddField (N->getText(), (CHAR8 *) "UINT16", ArrayNum), N); >> 379 ; 380 381dataStructField8 : 382 << UINT32 ArrayNum = 0; >> 383 D:"UINT8" 384 N:StringIdentifier 385 { 386 OpenBracket I:Number CloseBracket << ArrayNum = _STOU32(I->getText(), I->getLine()); >> 387 } 388 ";" << _PCATCH(gCVfrVarDataTypeDB.DataTypeAddField (N->getText(), D->getText(), ArrayNum), N); >> 389 ; 390 391dataStructFieldBool : 392 << UINT32 ArrayNum = 0; >> 393 D:"BOOLEAN" 394 N:StringIdentifier 395 { 396 OpenBracket I:Number CloseBracket << ArrayNum = _STOU32(I->getText(), I->getLine()); >> 397 } 398 ";" << _PCATCH(gCVfrVarDataTypeDB.DataTypeAddField (N->getText(), D->getText(), ArrayNum), N); >> 399 ; 400 401dataStructFieldString : 402 << UINT32 ArrayNum = 0; >> 403 D:"EFI_STRING_ID" 404 N:StringIdentifier 405 { 406 OpenBracket I:Number CloseBracket << ArrayNum = _STOU32(I->getText(), I->getLine()); >> 407 } 408 ";" << _PCATCH(gCVfrVarDataTypeDB.DataTypeAddField (N->getText(), D->getText(), ArrayNum), N); >> 409 ; 410 411dataStructFieldDate : 412 << UINT32 ArrayNum = 0; >> 413 D:"EFI_HII_DATE" 414 N:StringIdentifier 415 { 416 OpenBracket I:Number CloseBracket << ArrayNum = _STOU32(I->getText(), I->getLine()); >> 417 } 418 ";" << _PCATCH(gCVfrVarDataTypeDB.DataTypeAddField (N->getText(), D->getText(), ArrayNum), N); >> 419 ; 420 421dataStructFieldTime : 422 << UINT32 ArrayNum = 0; >> 423 D:"EFI_HII_TIME" 424 N:StringIdentifier 425 { 426 OpenBracket I:Number CloseBracket << ArrayNum = _STOU32(I->getText(), I->getLine()); >> 427 } 428 ";" << _PCATCH(gCVfrVarDataTypeDB.DataTypeAddField (N->getText(), D->getText(), ArrayNum), N); >> 429 ; 430 431dataStructFieldRef : 432 << UINT32 ArrayNum = 0; >> 433 D:"EFI_HII_REF" 434 N:StringIdentifier 435 { 436 OpenBracket I:Number CloseBracket << ArrayNum = _STOU32(I->getText(), I->getLine()); >> 437 } 438 ";" << _PCATCH(gCVfrVarDataTypeDB.DataTypeAddField (N->getText(), D->getText(), ArrayNum), N); >> 439 ; 440 441dataStructFieldUser : 442 << UINT32 ArrayNum = 0; >> 443 T:StringIdentifier 444 N:StringIdentifier 445 { 446 OpenBracket I:Number CloseBracket << ArrayNum = _STOU32(I->getText(), I->getLine()); >> 447 } 448 ";" << _PCATCH(gCVfrVarDataTypeDB.DataTypeAddField (N->getText(), T->getText(), ArrayNum), T); >> 449 ; 450 451//***************************************************************************** 452// 453// the syntax of GUID definition 454// 455guidSubDefinition [EFI_GUID &Guid] : 456 G4:Number "," G5:Number "," G6:Number "," G7:Number "," G8:Number "," G9:Number "," G10:Number "," G11:Number 457 << 458 Guid.Data4[0] = _STOU8(G4->getText(), G4->getLine()); 459 Guid.Data4[1] = _STOU8(G5->getText(), G5->getLine()); 460 Guid.Data4[2] = _STOU8(G6->getText(), G6->getLine()); 461 Guid.Data4[3] = _STOU8(G7->getText(), G7->getLine()); 462 Guid.Data4[4] = _STOU8(G8->getText(), G8->getLine()); 463 Guid.Data4[5] = _STOU8(G9->getText(), G9->getLine()); 464 Guid.Data4[6] = _STOU8(G10->getText(), G10->getLine()); 465 Guid.Data4[7] = _STOU8(G11->getText(), G11->getLine()); 466 >> 467 ; 468 469guidDefinition [EFI_GUID &Guid] : 470 OpenBrace 471 G1:Number "," G2:Number "," G3:Number "," 472 << 473 Guid.Data1 = _STOU32 (G1->getText(), G1->getLine()); 474 Guid.Data2 = _STOU16 (G2->getText(), G2->getLine()); 475 Guid.Data3 = _STOU16 (G3->getText(), G3->getLine()); 476 >> 477 ( 478 OpenBrace guidSubDefinition[Guid] CloseBrace 479 | guidSubDefinition[Guid] 480 ) 481 CloseBrace 482 ; 483 484//***************************************************************************** 485// 486// the syntax of form set definition 487// 488vfrFormSetDefinition : 489 << 490 EFI_GUID Guid; 491 EFI_GUID DefaultClassGuid = EFI_HII_PLATFORM_SETUP_FORMSET_GUID; 492 EFI_GUID ClassGuid1, ClassGuid2, ClassGuid3; 493 UINT8 ClassGuidNum = 0; 494 CIfrFormSet *FSObj = NULL; 495 UINT16 C, SC; 496 CHAR8* InsertOpcodeAddr = NULL; 497 >> 498 L:FormSet 499 Uuid "=" guidDefinition[Guid] "," 500 Title "=" "STRING_TOKEN" "\(" S1:Number "\)" "," 501 Help "=" "STRING_TOKEN" "\(" S2:Number "\)" "," 502 { 503 ClassGuid "=" guidDefinition[ClassGuid1] << ++ClassGuidNum; >> 504 { 505 "\|" guidDefinition[ClassGuid2] << ++ClassGuidNum; >> 506 { 507 "\|" guidDefinition[ClassGuid3] << ++ClassGuidNum; >> 508 } 509 } 510 "," 511 } 512 << 513 if (mOverrideClassGuid != NULL && ClassGuidNum >= 3) { 514 _PCATCH (VFR_RETURN_INVALID_PARAMETER, L->getLine(), "Already has 3 class guids, can't add extra class guid!"); 515 } 516 switch (ClassGuidNum) { 517 case 0: 518 if (mOverrideClassGuid != NULL) { 519 ClassGuidNum = 2; 520 } else { 521 ClassGuidNum = 1; 522 } 523 FSObj = new CIfrFormSet(sizeof(EFI_IFR_FORM_SET) + ClassGuidNum * sizeof(EFI_GUID)); 524 FSObj->SetClassGuid(&DefaultClassGuid); 525 if (mOverrideClassGuid != NULL) { 526 FSObj->SetClassGuid(mOverrideClassGuid); 527 } 528 break; 529 case 1: 530 if (mOverrideClassGuid != NULL) { 531 ClassGuidNum ++; 532 } 533 FSObj = new CIfrFormSet(sizeof(EFI_IFR_FORM_SET) + ClassGuidNum * sizeof(EFI_GUID)); 534 FSObj->SetClassGuid(&ClassGuid1); 535 if (mOverrideClassGuid != NULL) { 536 FSObj->SetClassGuid(mOverrideClassGuid); 537 } 538 break; 539 case 2: 540 if (mOverrideClassGuid != NULL) { 541 ClassGuidNum ++; 542 } 543 FSObj = new CIfrFormSet(sizeof(EFI_IFR_FORM_SET) + ClassGuidNum * sizeof(EFI_GUID)); 544 FSObj->SetClassGuid(&ClassGuid1); 545 FSObj->SetClassGuid(&ClassGuid2); 546 if (mOverrideClassGuid != NULL) { 547 FSObj->SetClassGuid(mOverrideClassGuid); 548 } 549 break; 550 case 3: 551 FSObj = new CIfrFormSet(sizeof(EFI_IFR_FORM_SET) + ClassGuidNum * sizeof(EFI_GUID)); 552 FSObj->SetClassGuid(&ClassGuid1); 553 FSObj->SetClassGuid(&ClassGuid2); 554 FSObj->SetClassGuid(&ClassGuid3); 555 break; 556 default: 557 break; 558 } 559 560 SET_LINE_INFO (*FSObj, L); 561 FSObj->SetGuid (&Guid); 562 // 563 // for framework vfr to store formset guid used by varstore and efivarstore 564 // 565 if (mCompatibleMode) { 566 memcpy (&mFormsetGuid, &Guid, sizeof (EFI_GUID)); 567 } 568 FSObj->SetFormSetTitle (_STOSID(S1->getText(), S1->getLine())); 569 FSObj->SetHelp (_STOSID(S2->getText(), S2->getLine())); 570 >> 571 { 572 FC:Class "=" classDefinition[C] "," << {CIfrClass CObj;SET_LINE_INFO (CObj, FC); CObj.SetClass(C);} >> 573 } 574 { 575 FSC:Subclass "=" subclassDefinition[SC] "," << {CIfrSubClass SCObj; SET_LINE_INFO (SCObj, FSC); SCObj.SetSubClass(SC);} >> 576 } 577 << 578 _DeclareStandardDefaultStorage (GET_LINENO (L)); 579 >> 580 vfrFormSetList 581 E:EndFormSet << 582 if (mCompatibleMode) { 583 // 584 // declare all undefined varstore and efivarstore 585 // 586 _DeclareDefaultFrameworkVarStore (GET_LINENO(E)); 587 } 588 589 // 590 // Declare undefined Question so that they can be used in expression. 591 // 592 if (gCFormPkg.HavePendingUnassigned()) { 593 mParserStatus += gCFormPkg.DeclarePendingQuestion ( 594 gCVfrVarDataTypeDB, 595 mCVfrDataStorage, 596 mCVfrQuestionDB, 597 &mFormsetGuid, 598 E->getLine(), 599 &InsertOpcodeAddr 600 ); 601 gNeedAdjustOpcode = TRUE; 602 } 603 604 CRT_END_OP (E); 605 606 // 607 // Adjust the pending question position. 608 // Move the position from current to before the end of the last form in the form set. 609 // 610 if (gNeedAdjustOpcode) { 611 gCFormPkg.AdjustDynamicInsertOpcode ( 612 mLastFormEndAddr, 613 InsertOpcodeAddr 614 ); 615 } 616 617 if (FSObj != NULL) { 618 delete FSObj; 619 } 620 >> 621 ";" 622 ; 623 624vfrFormSetList : 625 ( 626 vfrFormDefinition | 627 vfrFormMapDefinition | 628 vfrStatementImage | 629 vfrStatementVarStoreLinear | 630 vfrStatementVarStoreEfi | 631 vfrStatementVarStoreNameValue | 632 vfrStatementDefaultStore | 633 vfrStatementDisableIfFormSet | 634 vfrStatementSuppressIfFormSet | 635 vfrStatementExtension 636 )* 637 ; 638 639vfrStatementExtension: 640 << 641 EFI_GUID Guid; 642 CIfrGuid *GuidObj = NULL; 643 CHAR8 *TypeName = NULL; 644 UINT32 TypeSize = 0; 645 UINT8 *DataBuff = NULL; 646 UINT32 Size = 0; 647 UINT8 Idx = 0; 648 UINT32 LineNum; 649 BOOLEAN IsStruct = FALSE; 650 UINT32 ArrayNum = 0; 651 >> 652 L:GuidOp 653 Uuid "=" guidDefinition[Guid] 654 {"," DataType "=" 655 ( 656 U64:"UINT64" {OpenBracket AN1:Number CloseBracket <<ArrayNum = _STOU32(AN1->getText(), AN1->getLine());>>} 657 << TypeName = U64->getText(); LineNum = U64->getLine(); >> 658 | U32:"UINT32" {OpenBracket AN2:Number CloseBracket <<ArrayNum = _STOU32(AN2->getText(), AN2->getLine());>>} 659 << TypeName = U32->getText(); LineNum = U32->getLine(); >> 660 | U16:"UINT16" {OpenBracket AN3:Number CloseBracket <<ArrayNum = _STOU32(AN3->getText(), AN3->getLine());>>} 661 << TypeName = U16->getText(); LineNum = U16->getLine(); >> 662 | U8:"UINT8" {OpenBracket AN4:Number CloseBracket <<ArrayNum = _STOU32(AN4->getText(), AN4->getLine());>>} 663 << TypeName = U8->getText(); LineNum = U8->getLine(); >> 664 | BL:"BOOLEAN" {OpenBracket AN5:Number CloseBracket <<ArrayNum = _STOU32(AN5->getText(), AN5->getLine());>>} 665 << TypeName = BL->getText(); LineNum = BL->getLine(); >> 666 | SI:"EFI_STRING_ID" {OpenBracket AN6:Number CloseBracket <<ArrayNum = _STOU32(AN6->getText(), AN6->getLine());>>} 667 << TypeName = SI->getText(); LineNum = SI->getLine(); >> 668 | D:"EFI_HII_DATE" {OpenBracket AN7:Number CloseBracket <<ArrayNum = _STOU32(AN7->getText(), AN7->getLine());>>} 669 << TypeName = D->getText(); LineNum = D->getLine(); IsStruct = TRUE;>> 670 | T:"EFI_HII_TIME" {OpenBracket AN8:Number CloseBracket <<ArrayNum = _STOU32(AN8->getText(), AN8->getLine());>>} 671 << TypeName = T->getText(); LineNum = T->getLine(); IsStruct = TRUE;>> 672 | R:"EFI_HII_REF" {OpenBracket AN9:Number CloseBracket <<ArrayNum = _STOU32(AN9->getText(), AN9->getLine());>>} 673 << TypeName = R->getText(); LineNum = R->getLine(); IsStruct = TRUE;>> 674 | TN:StringIdentifier {OpenBracket AN10:Number CloseBracket <<ArrayNum = _STOU32(AN10->getText(), AN10->getLine());>>} 675 << TypeName = TN->getText(); LineNum = TN->getLine(); IsStruct = TRUE;>> 676 ) 677 << 678 _PCATCH(gCVfrVarDataTypeDB.GetDataTypeSize(TypeName, &TypeSize), LineNum); 679 if (ArrayNum > 0) { 680 Size = TypeSize*ArrayNum; 681 } else { 682 Size = TypeSize; 683 } 684 if (Size > (128 - sizeof (EFI_IFR_GUID))) return; 685 DataBuff = (UINT8 *)malloc(Size); 686 for (Idx = 0; Idx < Size; Idx++) { 687 DataBuff[Idx] = 0; 688 } 689 >> 690 vfrExtensionData [DataBuff, Size, TypeName, TypeSize, IsStruct, ArrayNum] 691 } 692 << 693 { 694 GuidObj = new CIfrGuid(Size); 695 if (GuidObj != NULL) { 696 GuidObj->SetLineNo(L->getLine()); 697 GuidObj->SetGuid (&Guid); 698 } 699 } 700 if (TypeName != NULL) { 701 GuidObj->SetData(DataBuff, Size); 702 } 703 >> 704 {"," 705 ( 706 vfrStatementExtension 707 )* 708 E:EndGuidOp << GuidObj->SetScope(1); CRT_END_OP (E); >> 709 } 710 << 711 if (GuidObj != NULL) delete GuidObj; 712 if (DataBuff != NULL) free(DataBuff); 713 >> 714 ";" 715; 716 717vfrExtensionData[UINT8 *DataBuff, UINT32 Size, CHAR8 *TypeName, UINT32 TypeSize, BOOLEAN IsStruct, UINT32 ArrayNum]: 718 << 719 CHAR8 *TFName = NULL; 720 UINT32 ArrayIdx = 0; 721 UINT16 FieldOffset; 722 UINT8 FieldType; 723 UINT32 FieldSize; 724 UINT64 Data_U64 = 0; 725 UINT32 Data_U32 = 0; 726 UINT16 Data_U16 = 0; 727 UINT8 Data_U8 = 0; 728 BOOLEAN Data_BL = 0; 729 EFI_STRING_ID Data_SID = 0; 730 BOOLEAN IsArray = FALSE; 731 UINT8 *ByteOffset = NULL; 732 >> 733( 734 ("," "data" {OpenBracket IDX1:Number CloseBracket <<IsArray = TRUE;>>} 735 << 736 ArrayIdx = 0; 737 if (IsArray == TRUE) { 738 ArrayIdx = _STOU8(IDX1->getText(), IDX1->getLine()); 739 if (ArrayIdx >= ArrayNum) return; 740 IsArray = FALSE; 741 } 742 ByteOffset = DataBuff + (ArrayIdx * TypeSize); 743 if (IsStruct == TRUE) { 744 _STRCAT(&TFName, TypeName); 745 } 746 >> 747 ("." FN:StringIdentifier 748 << 749 if (IsStruct == TRUE) { 750 _STRCAT(&TFName, "."); 751 _STRCAT(&TFName, FN->getText()); 752 } 753 >> 754 { 755 OpenBracket IDX2:Number CloseBracket 756 << 757 if (IsStruct == TRUE) { 758 _STRCAT(&TFName, "["); 759 _STRCAT(&TFName, IDX2->getText()); 760 _STRCAT(&TFName, "]"); 761 } 762 >> 763 } 764 )* 765 "=" RD:Number 766 << 767 if (IsStruct == FALSE) { 768 if (strcmp ("UINT64", TypeName) == 0) { 769 Data_U64 = _STOU64(RD->getText(), RD->getLine()); 770 memcpy (ByteOffset, &Data_U64, TypeSize); 771 }else if (strcmp ("UINT32", TypeName) == 0) { 772 Data_U32 = _STOU32(RD->getText(), RD->getLine()); 773 memcpy (ByteOffset, &Data_U32, TypeSize); 774 }else if (strcmp ("UINT16", TypeName) == 0) { 775 Data_U16 = _STOU16(RD->getText(), RD->getLine()); 776 memcpy (ByteOffset, &Data_U16, TypeSize); 777 }else if (strcmp ("UINT8", TypeName) == 0) { 778 Data_U8 = _STOU8(RD->getText(), RD->getLine()); 779 memcpy (ByteOffset, &Data_U8, TypeSize); 780 }else if (strcmp ("BOOLEAN", TypeName)== 0) { 781 Data_BL = _STOU8(RD->getText(), RD->getLine()); 782 memcpy (ByteOffset, &Data_BL, TypeSize); 783 }else if (strcmp ("EFI_STRING_ID", TypeName) == 0) { 784 Data_SID = _STOSID(RD->getText(), RD->getLine()); 785 memcpy (ByteOffset, &Data_SID, TypeSize); 786 } 787 } else { 788 gCVfrVarDataTypeDB.GetDataFieldInfo(TFName, FieldOffset, FieldType, FieldSize); 789 switch (FieldType) { 790 case EFI_IFR_TYPE_NUM_SIZE_8: 791 Data_U8 = _STOU8(RD->getText(), RD->getLine()); 792 memcpy (ByteOffset + FieldOffset, &Data_U8, FieldSize); 793 break; 794 case EFI_IFR_TYPE_NUM_SIZE_16: 795 Data_U16 = _STOU16(RD->getText(), RD->getLine()); 796 memcpy (ByteOffset + FieldOffset, &Data_U16, FieldSize); 797 break; 798 case EFI_IFR_TYPE_NUM_SIZE_32: 799 Data_U32 = _STOU32(RD->getText(), RD->getLine()); 800 memcpy (ByteOffset + FieldOffset, &Data_U32, FieldSize); 801 break; 802 case EFI_IFR_TYPE_NUM_SIZE_64: 803 Data_U64 = _STOU64(RD->getText(), RD->getLine()); 804 memcpy (ByteOffset + FieldOffset, &Data_U64, FieldSize); 805 break; 806 case EFI_IFR_TYPE_BOOLEAN: 807 Data_BL = _STOU8(RD->getText(), RD->getLine()); 808 memcpy (ByteOffset + FieldOffset, &Data_BL, FieldSize); 809 break; 810 case EFI_IFR_TYPE_STRING: 811 Data_SID = _STOSID(RD->getText(), RD->getLine()); 812 memcpy (ByteOffset + FieldOffset, &Data_SID, FieldSize); 813 break; 814 default: 815 break; 816 } 817 } 818 if (TFName != NULL) { delete TFName; TFName = NULL; } 819 >> 820 )* 821) 822; 823 824 825vfrStatementDefaultStore : 826 << UINT16 DefaultId = EFI_HII_DEFAULT_CLASS_STANDARD; >> 827 D:DefaultStore N:StringIdentifier "," 828 Prompt "=" "STRING_TOKEN" "\(" S:Number "\)" 829 { 830 "," Attribute "=" A:Number << DefaultId = _STOU16(A->getText(), A->getLine()); >> 831 } 832 << 833 if (mCVfrDefaultStore.DefaultIdRegistered (DefaultId) == FALSE) { 834 CIfrDefaultStore DSObj; 835 _PCATCH(mCVfrDefaultStore.RegisterDefaultStore (DSObj.GetObjBinAddr(), N->getText(), _STOSID(S->getText(), S->getLine()), DefaultId)), D->getLine(); 836 DSObj.SetLineNo(D->getLine()); 837 DSObj.SetDefaultName (_STOSID(S->getText(), S->getLine())); 838 DSObj.SetDefaultId (DefaultId); 839 } else { 840 _PCATCH(mCVfrDefaultStore.ReRegisterDefaultStoreById (DefaultId, N->getText(), _STOSID(S->getText(), S->getLine()))), D->getLine(); 841 } 842 >> 843 ";" 844 ; 845 846vfrStatementVarStoreLinear : 847 << 848 EFI_GUID Guid; 849 CIfrVarStore VSObj; 850 CHAR8 *TypeName; 851 CHAR8 *StoreName; 852 UINT32 LineNum; 853 EFI_VARSTORE_ID VarStoreId = EFI_VARSTORE_ID_INVALID; 854 UINT32 Size; 855 >> 856 V:Varstore << VSObj.SetLineNo(V->getLine()); >> 857 ( 858 TN:StringIdentifier "," << TypeName = TN->getText(); LineNum = TN->getLine(); >> 859 | U8:"UINT8" "," << TypeName = U8->getText(); LineNum = U8->getLine(); >> 860 | U16:"UINT16" "," << TypeName = U16->getText(); LineNum = U16->getLine(); >> 861 | C16:"CHAR16" "," << TypeName = (CHAR8 *) "UINT16"; LineNum = C16->getLine(); >> 862 | U32:"UINT32" "," << TypeName = U32->getText(); LineNum = U32->getLine(); >> 863 | U64:"UINT64" "," << TypeName = U64->getText(); LineNum = U64->getLine(); >> 864 | D:"EFI_HII_DATE" "," << TypeName = D->getText(); LineNum = D->getLine(); >> 865 | T:"EFI_HII_TIME" "," << TypeName = T->getText(); LineNum = T->getLine(); >> 866 | R:"EFI_HII_REF" "," << TypeName = R->getText(); LineNum = R->getLine(); >> 867 ) 868 { Key "=" FID:Number "," << // Key is used to assign Varid in Framework VFR but no use in UEFI2.1 VFR 869 if (mCompatibleMode) { 870 VarStoreId = _STOU16(FID->getText(), FID->getLine()); 871 } 872 >> 873 } 874 { 875 VarId "=" ID:Number "," << 876 _PCATCH( 877 (INTN)(VarStoreId = _STOU16(ID->getText(), ID->getLine())) != 0, 878 (INTN)TRUE, 879 ID, 880 "varid 0 is not allowed." 881 ); 882 >> 883 } 884 Name "=" SN:StringIdentifier "," 885 Uuid "=" guidDefinition[Guid] 886 << 887 if (mCompatibleMode) { 888 StoreName = TypeName; 889 } else { 890 StoreName = SN->getText(); 891 } 892 _PCATCH(mCVfrDataStorage.DeclareBufferVarStore ( 893 StoreName, 894 &Guid, 895 &gCVfrVarDataTypeDB, 896 TypeName, 897 VarStoreId 898 ), LineNum); 899 VSObj.SetGuid (&Guid); 900 _PCATCH(mCVfrDataStorage.GetVarStoreId(StoreName, &VarStoreId, &Guid), SN); 901 VSObj.SetVarStoreId (VarStoreId); 902 _PCATCH(gCVfrVarDataTypeDB.GetDataTypeSize(TypeName, &Size), LineNum); 903 VSObj.SetSize ((UINT16) Size); 904 VSObj.SetName (SN->getText()); 905 >> 906 ";" 907 ; 908 909vfrStatementVarStoreEfi : 910 << 911 BOOLEAN IsUEFI23EfiVarstore = TRUE; 912 EFI_GUID Guid; 913 CIfrVarStoreEfi VSEObj; 914 EFI_VARSTORE_ID VarStoreId = EFI_VARSTORE_ID_INVALID; 915 UINT32 Attr = 0; 916 UINT32 Size; 917 CHAR8 *TypeName; 918 UINT32 LineNum; 919 CHAR8 *StoreName = NULL; 920 BOOLEAN CustomizedName = FALSE; 921 >> 922 E:Efivarstore << VSEObj.SetLineNo(E->getLine()); >> 923 ( 924 TN:StringIdentifier "," << TypeName = TN->getText(); LineNum = TN->getLine(); CustomizedName = TRUE; >> 925 | U8:"UINT8" "," << TypeName = U8->getText(); LineNum = U8->getLine(); >> 926 | U16:"UINT16" "," << TypeName = U16->getText(); LineNum = U16->getLine(); >> 927 | C16:"CHAR16" "," << TypeName = (CHAR8 *) "UINT16"; LineNum = C16->getLine(); >> 928 | U32:"UINT32" "," << TypeName = U32->getText(); LineNum = U32->getLine(); >> 929 | U64:"UINT64" "," << TypeName = U64->getText(); LineNum = U64->getLine(); >> 930 | D:"EFI_HII_DATE" "," << TypeName = D->getText(); LineNum = D->getLine(); >> 931 | T:"EFI_HII_TIME" "," << TypeName = T->getText(); LineNum = T->getLine(); >> 932 | R:"EFI_HII_REF" "," << TypeName = R->getText(); LineNum = R->getLine(); >> 933 ) 934 { 935 VarId "=" ID:Number "," << 936 _PCATCH( 937 (INTN)(VarStoreId = _STOU16(ID->getText(), ID->getLine())) != 0, 938 (INTN)TRUE, 939 ID, 940 "varid 0 is not allowed." 941 ); 942 >> 943 } 944 Attribute "=" vfrVarStoreEfiAttr[Attr] ( "\|" vfrVarStoreEfiAttr[Attr] )* "," 945 << VSEObj.SetAttributes (Attr); >> 946 947 ( 948 Name "=" SN:StringIdentifier "," << StoreName = SN->getText(); >> 949 | 950 Name "=" "STRING_TOKEN" "\(" VN:Number "\)" "," 951 VarSize "=" N:Number "," << 952 IsUEFI23EfiVarstore = FALSE; 953 StoreName = gCVfrStringDB.GetVarStoreNameFormStringId(_STOSID(VN->getText(), VN->getLine())); 954 if (StoreName == NULL) { 955 _PCATCH (VFR_RETURN_UNSUPPORTED, VN->getLine(), "Can't get varstore name for this StringId!"); 956 } 957 if (!CustomizedName) { 958 _PCATCH (VFR_RETURN_UNSUPPORTED, E->getLine(), "Old style efivarstore must have String Identifier!"); 959 return; 960 } 961 Size = _STOU32(N->getText(), N->getLine()); 962 switch (Size) { 963 case 1: 964 TypeName = (CHAR8 *) "UINT8"; 965 break; 966 case 2: 967 TypeName = (CHAR8 *) "UINT16"; 968 break; 969 case 4: 970 TypeName = (CHAR8 *) "UINT32"; 971 break; 972 case 8: 973 TypeName = (CHAR8 *) "UINT64"; 974 break; 975 default: 976 _PCATCH (VFR_RETURN_UNSUPPORTED, N); 977 break; 978 } 979 >> 980 ) 981 982 Uuid "=" guidDefinition[Guid] << 983 if (IsUEFI23EfiVarstore) { 984 _PCATCH(mCVfrDataStorage.DeclareBufferVarStore ( 985 StoreName, 986 &Guid, 987 &gCVfrVarDataTypeDB, 988 TypeName, 989 VarStoreId 990 ), LineNum); 991 _PCATCH(mCVfrDataStorage.GetVarStoreId(StoreName, &VarStoreId, &Guid), SN); 992 _PCATCH(gCVfrVarDataTypeDB.GetDataTypeSize(TypeName, &Size), LineNum); 993 } else { 994 _PCATCH(mCVfrDataStorage.DeclareBufferVarStore ( 995 TN->getText(), 996 &Guid, 997 &gCVfrVarDataTypeDB, 998 TypeName, 999 VarStoreId 1000 ), LineNum); 1001 _PCATCH(mCVfrDataStorage.GetVarStoreId(TN->getText(), &VarStoreId, &Guid), VN); 1002 _PCATCH(gCVfrVarDataTypeDB.GetDataTypeSize(TypeName, &Size), N->getLine()); 1003 } 1004 VSEObj.SetGuid (&Guid); 1005 VSEObj.SetVarStoreId (VarStoreId); 1006 1007 VSEObj.SetSize ((UINT16) Size); 1008 VSEObj.SetName (StoreName); 1009 if (IsUEFI23EfiVarstore == FALSE && StoreName != NULL) { 1010 delete StoreName; 1011 } 1012 >> 1013 ";" 1014 ; 1015 1016vfrVarStoreEfiAttr [UINT32 & Attr] : 1017 N:Number << $Attr |= _STOU32(N->getText(), N->getLine()); >> 1018 ; 1019 1020vfrStatementVarStoreNameValue : 1021 << 1022 EFI_GUID Guid; 1023 CIfrVarStoreNameValue VSNVObj; 1024 EFI_VARSTORE_ID VarStoreId = EFI_VARSTORE_ID_INVALID; 1025 BOOLEAN Created = FALSE; 1026 >> 1027 L:NameValueVarStore << VSNVObj.SetLineNo(L->getLine()); >> 1028 SN:StringIdentifier "," 1029 { 1030 VarId "=" ID:Number "," << 1031 _PCATCH( 1032 (INTN)(VarStoreId = _STOU16(ID->getText(), ID->getLine())) != 0, 1033 (INTN)TRUE, 1034 ID, 1035 "varid 0 is not allowed." 1036 ); 1037 >> 1038 } 1039 ( 1040 Name "=" "STRING_TOKEN" "\(" N:Number "\)" "," << 1041 if (!Created) { 1042 _PCATCH(mCVfrDataStorage.DeclareNameVarStoreBegin (SN->getText(), VarStoreId), SN); 1043 Created = TRUE; 1044 } 1045 _PCATCH(mCVfrDataStorage.NameTableAddItem (_STOSID(N->getText(), N->getLine())), SN); 1046 >> 1047 )+ 1048 Uuid "=" guidDefinition[Guid] << _PCATCH(mCVfrDataStorage.DeclareNameVarStoreEnd (&Guid), SN); >> 1049 << 1050 VSNVObj.SetGuid (&Guid); 1051 _PCATCH(mCVfrDataStorage.GetVarStoreId(SN->getText(), &VarStoreId, &Guid), SN); 1052 VSNVObj.SetVarStoreId (VarStoreId); 1053 >> 1054 ";" 1055 ; 1056 1057// 1058// keep classDeinition and validClassNames for compatibility but not generate 1059// any IFR object 1060// 1061classDefinition[UINT16 & Class] : 1062 << $Class = 0; >> 1063 validClassNames[$Class] ( "\|" validClassNames[$Class] )* 1064 ; 1065 1066validClassNames[UINT16 & Class] : 1067 ClassNonDevice << $Class |= EFI_NON_DEVICE_CLASS; >> 1068 | ClassDiskDevice << $Class |= EFI_DISK_DEVICE_CLASS; >> 1069 | ClassVideoDevice << $Class |= EFI_VIDEO_DEVICE_CLASS; >> 1070 | ClassNetworkDevice << $Class |= EFI_NETWORK_DEVICE_CLASS; >> 1071 | ClassInputDevice << $Class |= EFI_INPUT_DEVICE_CLASS; >> 1072 | ClassOnBoardDevice << $Class |= EFI_ON_BOARD_DEVICE_CLASS; >> 1073 | ClassOtherDevice << $Class |= EFI_OTHER_DEVICE_CLASS; >> 1074 | N:Number << $Class |= _STOU16(N->getText(), N->getLine()); >> 1075 ; 1076 1077subclassDefinition[UINT16 & SubClass] : 1078 << $SubClass = 0; >> 1079 SubclassSetupApplication << $SubClass |= EFI_SETUP_APPLICATION_SUBCLASS; >> 1080 | SubclassGeneralApplication << $SubClass |= EFI_GENERAL_APPLICATION_SUBCLASS; >> 1081 | SubclassFrontPage << $SubClass |= EFI_FRONT_PAGE_SUBCLASS; >> 1082 | SubclassSingleUse << $SubClass |= EFI_SINGLE_USE_SUBCLASS; >> 1083 | N:Number << $SubClass |= _STOU16(N->getText(), N->getLine()); >> 1084 ; 1085 1086vfrStatementDisableIfFormSet : 1087 << 1088 CIfrDisableIf DIObj; 1089 mConstantOnlyInExpression = TRUE; 1090 >> 1091 D:DisableIf << DIObj.SetLineNo(D->getLine()); >> 1092 vfrStatementExpression[0] ";" << mConstantOnlyInExpression = FALSE; >> 1093 vfrFormSetList 1094 E:EndIf << CRT_END_OP (E); >> 1095 ";" 1096 ; 1097 1098vfrStatementSuppressIfFormSet : 1099 << CIfrSuppressIf SIObj;>> 1100 L:SuppressIf << 1101 if (mCompatibleMode) { 1102 _PCATCH (VFR_RETURN_UNSUPPORTED, L); 1103 } 1104 SIObj.SetLineNo(L->getLine()); 1105 >> 1106 { FLAGS "=" flagsField ( "\|" flagsField )* "," } 1107 vfrStatementExpression[0] ";" 1108 vfrFormSetList 1109 E: EndIf 1110 ";" << CRT_END_OP (E); >> 1111 ; 1112 1113//***************************************************************************** 1114// 1115// the syntax of question header and statement header 1116// 1117vfrStatementHeader[CIfrStatementHeader *SHObj] : 1118 Prompt "=" "STRING_TOKEN" "\(" S1:Number "\)" "," << $SHObj->SetPrompt (_STOSID(S1->getText(), S1->getLine())); >> 1119 Help "=" "STRING_TOKEN" "\(" S2:Number "\)" << $SHObj->SetHelp (_STOSID(S2->getText(), S2->getLine())); >> 1120 ; 1121 1122vfrQuestionHeader[CIfrQuestionHeader & QHObj, EFI_QUESION_TYPE QType = QUESTION_NORMAL]: 1123 << 1124 EFI_VARSTORE_INFO Info; 1125 Info.mVarType = EFI_IFR_TYPE_OTHER; 1126 Info.mVarTotalSize = 0; 1127 Info.mInfo.mVarOffset = EFI_VAROFFSET_INVALID; 1128 Info.mVarStoreId = EFI_VARSTORE_ID_INVALID; 1129 EFI_QUESTION_ID QId = EFI_QUESTION_ID_INVALID; 1130 CHAR8 *QName = NULL; 1131 CHAR8 *VarIdStr = NULL; 1132 mUsedDefaultCount = 0; 1133 >> 1134 { 1135 Name "=" QN:StringIdentifier "," << 1136 QName = QN->getText(); 1137 _PCATCH(mCVfrQuestionDB.FindQuestion (QName), VFR_RETURN_UNDEFINED, QN, "has already been used please used anther name"); 1138 >> 1139 } 1140 { V:VarId "=" vfrStorageVarId[Info, VarIdStr] "," } 1141 { 1142 QuestionId "=" ID:Number "," << 1143 QId = _STOQID(ID->getText(), ID->getLine()); 1144 _PCATCH(mCVfrQuestionDB.FindQuestion (QId), VFR_RETURN_UNDEFINED, ID, "has already been used please assign another number"); 1145 >> 1146 } 1147 << 1148 switch (QType) { 1149 case QUESTION_NORMAL: 1150 mCVfrQuestionDB.RegisterQuestion (QName, VarIdStr, QId); 1151 break; 1152 case QUESTION_DATE: 1153 mCVfrQuestionDB.RegisterNewDateQuestion (QName, VarIdStr, QId); 1154 break; 1155 case QUESTION_TIME: 1156 mCVfrQuestionDB.RegisterNewTimeQuestion (QName, VarIdStr, QId); 1157 break; 1158 case QUESTION_REF: 1159 // 1160 // VarIdStr != NULL stand for question with storagae. 1161 // 1162 if (VarIdStr != NULL) { 1163 mCVfrQuestionDB.RegisterRefQuestion (QName, VarIdStr, QId); 1164 } else { 1165 mCVfrQuestionDB.RegisterQuestion (QName, NULL, QId); 1166 } 1167 break; 1168 default: 1169 _PCATCH(VFR_RETURN_FATAL_ERROR); 1170 } 1171 $QHObj.SetQuestionId (QId); 1172 if (VarIdStr != NULL) { 1173 $QHObj.SetVarStoreInfo (&Info); 1174 } 1175 >> 1176 vfrStatementHeader[&$QHObj] 1177 << 1178 if (VarIdStr != NULL) { 1179 delete VarIdStr; 1180 } 1181 _SAVE_CURRQEST_VARINFO (Info); 1182 >> 1183 ; 1184 1185questionheaderFlagsField[UINT8 & Flags] : 1186 ReadOnlyFlag << $Flags |= 0x01; >> 1187 | InteractiveFlag << $Flags |= 0x04; >> 1188 | ResetRequiredFlag << $Flags |= 0x10; >> 1189 | O:OptionOnlyFlag << 1190 if (mCompatibleMode) { 1191 $Flags |= 0x80; 1192 } else { 1193 gCVfrErrorHandle.HandleWarning ( 1194 VFR_WARNING_OBSOLETED_FRAMEWORK_OPCODE, 1195 O->getLine(), 1196 O->getText() 1197 ); 1198 } 1199 >> 1200 | N:NVAccessFlag << 1201 if (!mCompatibleMode) { 1202 gCVfrErrorHandle.HandleWarning ( 1203 VFR_WARNING_OBSOLETED_FRAMEWORK_OPCODE, 1204 N->getLine(), 1205 N->getText() 1206 ); 1207 } 1208 >> 1209 | L:LateCheckFlag << 1210 if (!mCompatibleMode) { 1211 gCVfrErrorHandle.HandleWarning ( 1212 VFR_WARNING_OBSOLETED_FRAMEWORK_OPCODE, 1213 L->getLine(), 1214 L->getText() 1215 ); 1216 } 1217 >> 1218 ; 1219 1220vfrStorageVarId[EFI_VARSTORE_INFO & Info, CHAR8 *&QuestVarIdStr, BOOLEAN CheckFlag = TRUE] : 1221 << 1222 UINT32 Idx; 1223 UINT32 LineNo; 1224 EFI_VFR_VARSTORE_TYPE VarStoreType = EFI_VFR_VARSTORE_INVALID; 1225 CHAR8 *VarIdStr = NULL; 1226 CHAR8 *VarStr = NULL; 1227 CHAR8 *SName = NULL; 1228 CHAR8 *TName = NULL; 1229 EFI_VFR_RETURN_CODE VfrReturnCode = VFR_RETURN_SUCCESS; 1230 EFI_IFR_TYPE_VALUE Dummy = gZeroEfiIfrTypeValue; 1231 EFI_GUID *VarGuid = NULL; 1232 >> 1233 ( 1234 SN1:StringIdentifier << SName = SN1->getText(); _STRCAT(&VarIdStr, SN1->getText()); >> 1235 OpenBracket I1:Number CloseBracket << 1236 Idx = _STOU32(I1->getText(), I1->getLine()); 1237 _STRCAT(&VarIdStr, "["); 1238 _STRCAT(&VarIdStr, I1->getText()); 1239 _STRCAT(&VarIdStr, "]"); 1240 >> 1241 << 1242 VfrReturnCode = mCVfrDataStorage.GetVarStoreId(SName, &$Info.mVarStoreId); 1243 if (mCompatibleMode && VfrReturnCode == VFR_RETURN_UNDEFINED) { 1244 mCVfrDataStorage.DeclareBufferVarStore ( 1245 SName, 1246 &mFormsetGuid, 1247 &gCVfrVarDataTypeDB, 1248 SName, 1249 EFI_VARSTORE_ID_INVALID, 1250 FALSE 1251 ); 1252 VfrReturnCode = mCVfrDataStorage.GetVarStoreId(SName, &$Info.mVarStoreId, &mFormsetGuid); 1253 } 1254 if (CheckFlag || VfrReturnCode == VFR_RETURN_SUCCESS) { 1255 _PCATCH(VfrReturnCode, SN1); 1256 _PCATCH(mCVfrDataStorage.GetNameVarStoreInfo (&$Info, Idx), SN1); 1257 } 1258 1259 QuestVarIdStr = VarIdStr; 1260 >> 1261 ) 1262 | 1263 ( 1264 SN2:StringIdentifier << SName = SN2->getText(); _STRCAT(&VarIdStr, SName); >> 1265 << 1266 VfrReturnCode = mCVfrDataStorage.GetVarStoreId(SName, &$Info.mVarStoreId); 1267 if (mCompatibleMode && VfrReturnCode == VFR_RETURN_UNDEFINED) { 1268 mCVfrDataStorage.DeclareBufferVarStore ( 1269 SName, 1270 &mFormsetGuid, 1271 &gCVfrVarDataTypeDB, 1272 SName, 1273 EFI_VARSTORE_ID_INVALID, 1274 FALSE 1275 ); 1276 VfrReturnCode = mCVfrDataStorage.GetVarStoreId(SName, &$Info.mVarStoreId, &mFormsetGuid); 1277 } 1278 if (CheckFlag || VfrReturnCode == VFR_RETURN_SUCCESS) { 1279 _PCATCH(VfrReturnCode, SN2); 1280 VarStoreType = mCVfrDataStorage.GetVarStoreType ($Info.mVarStoreId); 1281 if (VarStoreType == EFI_VFR_VARSTORE_BUFFER) { 1282 _PCATCH(mCVfrDataStorage.GetBufferVarStoreDataTypeName(Info.mVarStoreId, &TName), SN2); 1283 _STRCAT(&VarStr, TName); 1284 } 1285 } 1286 >> 1287 1288 ( 1289 "." << 1290 if (CheckFlag || VfrReturnCode == VFR_RETURN_SUCCESS) { 1291 _PCATCH(((VarStoreType != EFI_VFR_VARSTORE_BUFFER) ? VFR_RETURN_EFIVARSTORE_USE_ERROR : VFR_RETURN_SUCCESS), SN2); 1292 } 1293 _STRCAT(&VarIdStr, "."); _STRCAT(&VarStr, "."); 1294 >> 1295 SF:StringIdentifier << _STRCAT(&VarIdStr, SF->getText()); _STRCAT(&VarStr, SF->getText()); >> 1296 { 1297 OpenBracket I2:Number CloseBracket << 1298 Idx = _STOU32(I2->getText(), I2->getLine()); 1299 if (mCompatibleMode) Idx --; 1300 if (Idx > 0) { 1301 // 1302 // Idx == 0, [0] can be ignored. 1303 // Array[0] is same to Array for unify the varid name to cover [0] 1304 // 1305 _STRCAT(&VarIdStr, "["); 1306 _STRCAT(&VarIdStr, I2->getText()); 1307 _STRCAT(&VarIdStr, "]"); 1308 } 1309 _STRCAT(&VarStr, "["); 1310 _STRCAT(&VarStr, I2->getText()); 1311 _STRCAT(&VarStr, "]"); 1312 >> 1313 } 1314 )* << 1315 switch (VarStoreType) { 1316 case EFI_VFR_VARSTORE_EFI: 1317 _PCATCH(mCVfrDataStorage.GetEfiVarStoreInfo (&$Info), SN2); 1318 break; 1319 case EFI_VFR_VARSTORE_BUFFER: 1320 _PCATCH(gCVfrVarDataTypeDB.GetDataFieldInfo (VarStr, $Info.mInfo.mVarOffset, $Info.mVarType, $Info.mVarTotalSize), SN2->getLine(), VarStr); 1321 VarGuid = mCVfrDataStorage.GetVarStoreGuid($Info.mVarStoreId); 1322 _PCATCH((EFI_VFR_RETURN_CODE)gCVfrBufferConfig.Register ( 1323 SName, 1324 VarGuid, 1325 NULL), 1326 SN2->getLine()); 1327 _PCATCH((EFI_VFR_RETURN_CODE)gCVfrBufferConfig.Write ( 1328 'a', 1329 SName, 1330 VarGuid, 1331 NULL, 1332 $Info.mVarType, 1333 $Info.mInfo.mVarOffset, 1334 $Info.mVarTotalSize, 1335 Dummy), 1336 SN2->getLine()); 1337 break; 1338 case EFI_VFR_VARSTORE_NAME: 1339 default: break; 1340 } 1341 1342 QuestVarIdStr = VarIdStr; 1343 if (VarStr != NULL) {delete VarStr;} 1344 >> 1345 ) 1346 ; 1347 1348vfrQuestionDataFieldName [EFI_QUESTION_ID &QId, UINT32 &Mask, CHAR8 *&VarIdStr, UINT32 &LineNo] : 1349 << 1350 UINT32 Idx; 1351 VarIdStr = NULL; LineNo = 0; 1352 >> 1353 ( 1354 SN1:StringIdentifier << _STRCAT(&VarIdStr, SN1->getText()); LineNo = SN1->getLine(); >> 1355 OpenBracket I1:Number CloseBracket << 1356 _STRCAT(&VarIdStr, "["); 1357 _STRCAT(&VarIdStr, I1->getText()); 1358 _STRCAT(&VarIdStr, "]"); 1359 mCVfrQuestionDB.GetQuestionId (NULL, VarIdStr, $QId, $Mask); 1360 if (mConstantOnlyInExpression) { 1361 _PCATCH(VFR_RETURN_CONSTANT_ONLY, LineNo); 1362 } 1363 >> 1364 ) 1365 | 1366 ( 1367 SN2:StringIdentifier << _STRCAT (&VarIdStr, SN2->getText()); LineNo = SN2->getLine(); >> 1368 ( 1369 "." << 1370 _STRCAT (&VarIdStr, "."); 1371 if (mConstantOnlyInExpression) { 1372 _PCATCH(VFR_RETURN_CONSTANT_ONLY, LineNo); 1373 } 1374 >> 1375 SF:StringIdentifier << _STRCAT (&VarIdStr, SF->getText()); >> 1376 { 1377 OpenBracket I2:Number CloseBracket << 1378 Idx = _STOU32(I2->getText(), I2->getLine()); 1379 if (mCompatibleMode) Idx --; 1380 if (Idx > 0) { 1381 // 1382 // Idx == 0, [0] can be ignored. 1383 // Array[0] is same to Array 1384 // 1385 _STRCAT(&VarIdStr, "["); 1386 _STRCAT(&VarIdStr, I2->getText()); 1387 _STRCAT(&VarIdStr, "]"); 1388 } 1389 >> 1390 } 1391 )* 1392 << mCVfrQuestionDB.GetQuestionId (NULL, VarIdStr, $QId, $Mask); >> 1393 ) 1394 ; 1395 1396vfrConstantValueField[UINT8 Type] > [EFI_IFR_TYPE_VALUE Value] : 1397 << 1398 EFI_GUID Guid; 1399 >> 1400 N1:Number << 1401 switch ($Type) { 1402 case EFI_IFR_TYPE_NUM_SIZE_8 : 1403 $Value.u8 = _STOU8(N1->getText(), N1->getLine()); 1404 break; 1405 case EFI_IFR_TYPE_NUM_SIZE_16 : 1406 $Value.u16 = _STOU16(N1->getText(), N1->getLine()); 1407 break; 1408 case EFI_IFR_TYPE_NUM_SIZE_32 : 1409 $Value.u32 = _STOU32(N1->getText(), N1->getLine()); 1410 break; 1411 case EFI_IFR_TYPE_NUM_SIZE_64 : 1412 $Value.u64 = _STOU64(N1->getText(), N1->getLine()); 1413 break; 1414 case EFI_IFR_TYPE_BOOLEAN : 1415 $Value.b = _STOU8(N1->getText(), N1->getLine()); 1416 break; 1417 case EFI_IFR_TYPE_STRING : 1418 $Value.string = _STOU16(N1->getText(), N1->getLine()); 1419 break; 1420 case EFI_IFR_TYPE_TIME : 1421 case EFI_IFR_TYPE_DATE : 1422 case EFI_IFR_TYPE_REF : 1423 default : 1424 break; 1425 } 1426 >> 1427 | B1:True << $Value.b = TRUE; >> 1428 | B2:False << $Value.b = FALSE; >> 1429 | O1:One << $Value.u8 = _STOU8(O1->getText(), O1->getLine()); >> 1430 | O2:Ones << $Value.u64 = _STOU64(O2->getText(), O2->getLine()); >> 1431 | Z:Zero << $Value.u8 = _STOU8(Z->getText(), Z->getLine()); >> 1432 | HOUR:Number ":" MINUTE:Number ":" SECOND:Number << $Value.time = _STOT(HOUR->getText(), MINUTE->getText(),SECOND->getText(), HOUR->getLine()); >> 1433 | YEAR:Number "/" MONTH:Number "/" DAY:Number << $Value.date = _STOD(YEAR->getText(), MONTH->getText(), DAY->getText(), YEAR->getLine()); >> 1434 | QI:Number";" FI:Number";" guidDefinition[Guid] ";" "STRING_TOKEN" "\(" DP:Number "\)" 1435 << $Value.ref = _STOR(QI->getText(), FI->getText(), &Guid, DP->getText(), QI->getLine()); >> 1436 | "STRING_TOKEN" "\(" S1:Number "\)" << $Value.string = _STOSID(S1->getText(), S1->getLine()); >> 1437 ; 1438 1439//***************************************************************************** 1440// 1441// the syntax of form definition 1442// 1443vfrFormDefinition : 1444 << CIfrForm FObj; >> 1445 F:Form << FObj.SetLineNo(F->getLine()); >> 1446 FormId "=" S1:Number "," << _PCATCH(FObj.SetFormId (_STOFID(S1->getText(), S1->getLine())), S1); >> 1447 Title "=" "STRING_TOKEN" "\(" S2:Number "\)" ";" << FObj.SetFormTitle (_STOSID(S2->getText(), S2->getLine())); >> 1448 ( 1449 vfrStatementImage | 1450 vfrStatementLocked | 1451 vfrStatementRules | 1452 vfrStatementDefault | 1453 vfrStatementStat | 1454 vfrStatementQuestions | 1455 vfrStatementConditional | 1456 vfrStatementLabel | 1457 vfrStatementBanner | 1458 // Just for framework vfr compatibility 1459 vfrStatementInvalid | 1460 vfrStatementExtension | 1461 vfrStatementModal 1462 )* 1463 E:EndForm << 1464 if (mCompatibleMode) { 1465 // 1466 // Add Label for Framework Vfr 1467 // 1468 CIfrLabel LObj1; 1469 LObj1.SetLineNo(E->getLine()); 1470 LObj1.SetNumber (0xffff); //add end label for UEFI, label number hardcode 0xffff 1471 CIfrLabel LObj2; 1472 LObj2.SetLineNo(E->getLine()); 1473 LObj2.SetNumber (0x0); //add dummy label for UEFI, label number hardcode 0x0 1474 CIfrLabel LObj3; 1475 LObj3.SetLineNo(E->getLine()); 1476 LObj3.SetNumber (0xffff); //add end label for UEFI, label number hardcode 0xffff 1477 } 1478 1479 {CIfrEnd EObj; EObj.SetLineNo (E->getLine()); mLastFormEndAddr = EObj.GetObjBinAddr (); gAdjustOpcodeOffset = EObj.GetObjBinOffset ();} 1480 >> 1481 ";" 1482 ; 1483 1484vfrFormMapDefinition : 1485 << 1486 CIfrFormMap *FMapObj = NULL; 1487 UINT32 FormMapMethodNumber = 0; 1488 EFI_GUID Guid; 1489 >> 1490 F:FormMap << FMapObj = new CIfrFormMap(); FMapObj->SetLineNo(F->getLine()); >> 1491 FormId "=" S1:Number "," << _PCATCH(FMapObj->SetFormId (_STOFID(S1->getText(), S1->getLine())), S1); >> 1492 ( 1493 MapTitle "=" "STRING_TOKEN" "\(" S2:Number "\)" ";" 1494 MapGuid "=" guidDefinition[Guid] ";" << FMapObj->SetFormMapMethod (_STOFID(S2->getText(), S2->getLine()), &Guid); FormMapMethodNumber ++; >> 1495 )* << if (FormMapMethodNumber == 0) {_PCATCH (VFR_RETURN_INVALID_PARAMETER, F->getLine(), "No MapMethod is set for FormMap!");} delete FMapObj;>> 1496 ( 1497 vfrStatementImage | 1498 vfrStatementLocked | 1499 vfrStatementRules | 1500 vfrStatementDefault | 1501 vfrStatementStat | 1502 vfrStatementQuestions | 1503 vfrStatementConditional | 1504 vfrStatementLabel | 1505 vfrStatementBanner | 1506 vfrStatementExtension | 1507 vfrStatementModal 1508 )* 1509 E:EndForm << CRT_END_OP (E); >> 1510 ";" 1511 ; 1512 1513vfrStatementRules : 1514 << CIfrRule RObj; >> 1515 R:Rule << RObj.SetLineNo(R->getLine()); >> 1516 S1:StringIdentifier "," << 1517 mCVfrRulesDB.RegisterRule (S1->getText()); 1518 RObj.SetRuleId (mCVfrRulesDB.GetRuleId(S1->getText())); 1519 >> 1520 vfrStatementExpression[0] 1521 E:EndRule << CRT_END_OP (E); >> 1522 ";" 1523 ; 1524 1525vfrStatementDefault : 1526 << 1527 BOOLEAN IsExp = FALSE; 1528 EFI_IFR_TYPE_VALUE Val = gZeroEfiIfrTypeValue; 1529 CIfrDefault *DObj = NULL; 1530 CIfrDefault2 *DObj2 = NULL; 1531 EFI_DEFAULT_ID DefaultId = EFI_HII_DEFAULT_CLASS_STANDARD; 1532 CHAR8 *VarStoreName = NULL; 1533 EFI_VFR_VARSTORE_TYPE VarStoreType = EFI_VFR_VARSTORE_INVALID; 1534 UINT32 Size = 0; 1535 EFI_GUID *VarGuid = NULL; 1536 >> 1537 D:Default 1538 ( 1539 ( 1540 "=" vfrConstantValueField[_GET_CURRQEST_DATATYPE()] > [Val] "," 1541 << 1542 if (gCurrentMinMaxData != NULL && gCurrentMinMaxData->IsNumericOpcode()) { 1543 //check default value is valid for Numeric Opcode 1544 if (Val.u64 < gCurrentMinMaxData->GetMinData(_GET_CURRQEST_DATATYPE()) || Val.u64 > gCurrentMinMaxData->GetMaxData(_GET_CURRQEST_DATATYPE())) { 1545 _PCATCH (VFR_RETURN_INVALID_PARAMETER, D->getLine(), "Numeric default value must be between MinValue and MaxValue."); 1546 } 1547 } 1548 if (_GET_CURRQEST_DATATYPE() == EFI_IFR_TYPE_OTHER) { 1549 _PCATCH (VFR_RETURN_FATAL_ERROR, D->getLine(), "Default data type error."); 1550 Size = sizeof (EFI_IFR_TYPE_VALUE); 1551 } else { 1552 _PCATCH (gCVfrVarDataTypeDB.GetDataTypeSize (_GET_CURRQEST_DATATYPE(), &Size), D->getLine()); 1553 } 1554 Size += OFFSET_OF (EFI_IFR_DEFAULT, Value); 1555 DObj = new CIfrDefault ((UINT8)Size); 1556 DObj->SetLineNo(D->getLine()); 1557 DObj->SetType (_GET_CURRQEST_DATATYPE()); 1558 DObj->SetValue(Val); 1559 >> 1560 | << IsExp = TRUE; DObj2 = new CIfrDefault2; DObj2->SetLineNo(D->getLine()); DObj2->SetScope (1); >> 1561 vfrStatementValue "," << CIfrEnd EndObj1; EndObj1.SetLineNo(D->getLine()); >> 1562 ) 1563 { 1564 DefaultStore "=" SN:StringIdentifier "," << 1565 _PCATCH(mCVfrDefaultStore.GetDefaultId (SN->getText(), &DefaultId), SN); 1566 if (DObj != NULL) { 1567 DObj->SetDefaultId (DefaultId); 1568 } 1569 1570 if (DObj2 != NULL) { 1571 DObj2->SetDefaultId (DefaultId); 1572 } 1573 >> 1574 } 1575 << 1576 CheckDuplicateDefaultValue (DefaultId, D); 1577 if (_GET_CURRQEST_VARTINFO().mVarStoreId != EFI_VARSTORE_ID_INVALID) { 1578 _PCATCH(mCVfrDataStorage.GetVarStoreName (_GET_CURRQEST_VARTINFO().mVarStoreId, &VarStoreName), D->getLine()); 1579 VarGuid = mCVfrDataStorage.GetVarStoreGuid(_GET_CURRQEST_VARTINFO().mVarStoreId); 1580 VarStoreType = mCVfrDataStorage.GetVarStoreType (_GET_CURRQEST_VARTINFO().mVarStoreId); 1581 if ((IsExp == FALSE) && (VarStoreType == EFI_VFR_VARSTORE_BUFFER)) { 1582 _PCATCH(mCVfrDefaultStore.BufferVarStoreAltConfigAdd ( 1583 DefaultId, 1584 _GET_CURRQEST_VARTINFO(), 1585 VarStoreName, 1586 VarGuid, 1587 _GET_CURRQEST_DATATYPE (), 1588 Val), 1589 D->getLine() 1590 ); 1591 } 1592 } 1593 if (DObj != NULL) {delete DObj;} 1594 if (DObj2 != NULL) {delete DObj2;} 1595 >> 1596 ) 1597 ; 1598 1599vfrStatementStat : 1600 vfrStatementSubTitle | 1601 vfrStatementStaticText | 1602 vfrStatementCrossReference 1603 ; 1604 1605vfrStatementQuestions : 1606 vfrStatementBooleanType | 1607 vfrStatementDate | 1608 vfrStatementNumericType | 1609 vfrStatementStringType | 1610 vfrStatementOrderedList | 1611 vfrStatementTime 1612 ; 1613 1614vfrStatementConditional : 1615 vfrStatementDisableIfStat | 1616 vfrStatementSuppressIfStat | //enhance to be compatible for framework endif 1617 vfrStatementGrayOutIfStat | 1618 vfrStatementInconsistentIfStat //to be compatible for framework 1619 ; 1620 1621vfrStatementConditionalNew : 1622 vfrStatementDisableIfStat | 1623 vfrStatementSuppressIfStatNew | 1624 vfrStatementGrayOutIfStatNew | 1625 vfrStatementInconsistentIfStat //to be compatible for framework 1626 ; 1627 1628vfrStatementSuppressIfStat : 1629 <<mCompatibleMode>>? vfrStatementSuppressIfStatOld 1630 | vfrStatementSuppressIfStatNew 1631 ; 1632 1633vfrStatementGrayOutIfStat : 1634 <<mCompatibleMode>>? vfrStatementGrayOutIfStatOld 1635 | vfrStatementGrayOutIfStatNew 1636 ; 1637 1638vfrStatementInvalid : 1639 ( 1640 vfrStatementInvalidHidden | 1641 vfrStatementInvalidInventory | 1642 vfrStatementInvalidSaveRestoreDefaults 1643 ) 1644 << _CRT_OP (TRUE); >> 1645 ; 1646 1647flagsField : 1648 Number 1649 | InteractiveFlag 1650 | ManufacturingFlag 1651 | DefaultFlag 1652 | ResetRequiredFlag 1653 | N:NVAccessFlag << 1654 if (!mCompatibleMode) { 1655 gCVfrErrorHandle.HandleWarning ( 1656 VFR_WARNING_OBSOLETED_FRAMEWORK_OPCODE, 1657 N->getLine(), 1658 N->getText() 1659 ); 1660 } 1661 >> 1662 | L:LateCheckFlag << 1663 if (!mCompatibleMode) { 1664 gCVfrErrorHandle.HandleWarning ( 1665 VFR_WARNING_OBSOLETED_FRAMEWORK_OPCODE, 1666 L->getLine(), 1667 L->getText() 1668 ); 1669 } 1670 >> 1671 ; 1672 1673vfrStatementValue : 1674 << CIfrValue VObj; >> 1675 V:Value << VObj.SetLineNo(V->getLine()); >> 1676 "=" vfrStatementExpression[0] << {CIfrEnd EndObj; EndObj.SetLineNo(V->getLine());} >> 1677 ; 1678 1679vfrStatementRead : 1680 << CIfrRead RObj; >> 1681 R:Read << RObj.SetLineNo(R->getLine()); >> 1682 vfrStatementExpression[0] ";" 1683 ; 1684 1685vfrStatementWrite : 1686 << CIfrWrite WObj; >> 1687 W:Write << WObj.SetLineNo(W->getLine()); >> 1688 vfrStatementExpression[0] ";" 1689 ; 1690 1691vfrStatementSubTitle : 1692 << CIfrSubtitle SObj; >> 1693 L:Subtitle << SObj.SetLineNo(L->getLine()); >> 1694 Text "=" "STRING_TOKEN" "\(" S:Number "\)" << SObj.SetPrompt (_STOSID(S->getText(), S->getLine())); >> 1695 { 1696 "," FLAGS "=" vfrSubtitleFlags[SObj] 1697 } 1698 ( 1699 {vfrStatementStatTagList "," } 1700 E:";" << CRT_END_OP (E); >> 1701 | 1702 { "," vfrStatementStatTagList} 1703 { "," (vfrStatementStat | vfrStatementQuestions)*} 1704 D: EndSubtitle ";" << CRT_END_OP (D); >> 1705 ) 1706 ; 1707 1708vfrSubtitleFlags [CIfrSubtitle & SObj] : 1709 << UINT8 LFlags = 0; >> 1710 subtitleFlagsField[LFlags] ( "\|" subtitleFlagsField[LFlags] )* 1711 << _PCATCH(SObj.SetFlags (LFlags)); >> 1712 ; 1713 1714subtitleFlagsField [UINT8 & Flags] : 1715 N:Number << $Flags |= _STOU8(N->getText(), N->getLine()); >> 1716 | "HORIZONTAL" << $Flags |= 0x01; >> 1717 ; 1718 1719vfrStatementStaticText : 1720 << 1721 UINT8 Flags = 0; 1722 EFI_QUESTION_ID QId = EFI_QUESTION_ID_INVALID; 1723 EFI_STRING_ID TxtTwo = EFI_STRING_ID_INVALID; 1724 >> 1725 T:Text 1726 Help "=" "STRING_TOKEN" "\(" S1:Number "\)" "," 1727 Text "=" "STRING_TOKEN" "\(" S2:Number "\)" 1728 { 1729 "," Text "=" "STRING_TOKEN" "\(" S3:Number "\)" << TxtTwo = _STOSID(S3->getText(), S3->getLine()); >> 1730 } 1731 { 1732 "," F:FLAGS "=" staticTextFlagsField[Flags] ( "\|" staticTextFlagsField[Flags] )* 1733 "," Key "=" KN:Number 1734 } 1735 << 1736 if (Flags & EFI_IFR_FLAG_CALLBACK) { 1737 if (TxtTwo != EFI_STRING_ID_INVALID) { 1738 gCVfrErrorHandle.HandleWarning ( 1739 VFR_WARNING_ACTION_WITH_TEXT_TWO, 1740 S3->getLine(), 1741 S3->getText() 1742 ); 1743 } 1744 CIfrAction AObj; 1745 mCVfrQuestionDB.RegisterQuestion (NULL, NULL, QId); 1746 AObj.SetLineNo (F->getLine()); 1747 AObj.SetQuestionId (QId); 1748 AObj.SetPrompt (_STOSID(S2->getText(), S2->getLine())); 1749 AObj.SetHelp (_STOSID(S1->getText(), S1->getLine())); 1750 _PCATCH(AObj.SetFlags (Flags), F->getLine()); 1751 AssignQuestionKey (AObj, KN); 1752 CRT_END_OP (KN); 1753 } else { 1754 CIfrText TObj; 1755 TObj.SetLineNo (T->getLine()); 1756 TObj.SetHelp (_STOSID(S1->getText(), S1->getLine())); 1757 TObj.SetPrompt (_STOSID(S2->getText(), S2->getLine())); 1758 TObj.SetTextTwo (TxtTwo); 1759 } 1760 >> 1761 { "," vfrStatementStatTagList } 1762 ";" 1763 ; 1764 1765staticTextFlagsField[UINT8 & HFlags] : 1766 N:Number << _PCATCH(_STOU8(N->getText(), N->getLine()) == 0 ? VFR_RETURN_SUCCESS : VFR_RETURN_UNSUPPORTED, N->getLine()); >> 1767 | questionheaderFlagsField[HFlags] 1768 ; 1769 1770vfrStatementCrossReference : 1771 vfrStatementGoto | 1772 vfrStatementResetButton 1773 ; 1774 1775vfrStatementGoto : 1776 << 1777 UINT8 RefType = 5; 1778 EFI_STRING_ID DevPath = EFI_STRING_ID_INVALID; 1779 EFI_GUID FSId = {0,}; 1780 EFI_FORM_ID FId; 1781 EFI_QUESTION_ID QId = EFI_QUESTION_ID_INVALID; 1782 UINT32 BitMask; 1783 CIfrQuestionHeader *QHObj = NULL; 1784 CIfrOpHeader *OHObj = NULL; 1785 CIfrRef *R1Obj = NULL; 1786 CIfrRef2 *R2Obj = NULL; 1787 CIfrRef3 *R3Obj = NULL; 1788 CIfrRef4 *R4Obj = NULL; 1789 CIfrRef5 *R5Obj = NULL; 1790 >> 1791 G:Goto 1792 { 1793 ( 1794 DevicePath "=" "STRING_TOKEN" "\(" P:Number "\)" "," 1795 FormSetGuid "=" guidDefinition[FSId] "," 1796 FormId "=" F1:Number "," 1797 Question "=" QN1:Number "," 1798 << 1799 RefType = 4; 1800 DevPath = _STOSID(P->getText(), P->getLine()); 1801 FId = _STOFID(F1->getText(), F1->getLine()); 1802 QId = _STOQID(QN1->getText(), QN1->getLine()); 1803 >> 1804 ) 1805 | 1806 ( 1807 FormSetGuid "=" guidDefinition[FSId] "," 1808 FormId "=" F2:Number "," 1809 Question "=" QN2:Number "," 1810 << 1811 RefType = 3; 1812 FId = _STOFID(F2->getText(), F2->getLine()); 1813 QId = _STOQID(QN2->getText(), QN2->getLine()); 1814 >> 1815 ) 1816 | 1817 ( 1818 FormId "=" F3:Number "," << RefType = 2; FId = _STOFID(F3->getText(), F3->getLine()); >> 1819 Question "=" 1820 ( 1821 QN3:StringIdentifier "," << 1822 mCVfrQuestionDB.GetQuestionId (QN3->getText (), NULL, QId, BitMask); 1823 if (QId == EFI_QUESTION_ID_INVALID) { 1824 _PCATCH(VFR_RETURN_UNDEFINED, QN3); 1825 } 1826 >> 1827 | QN4:Number "," << QId = _STOQID(QN4->getText(), QN4->getLine()); >> 1828 ) 1829 ) 1830 | 1831 ( 1832 F4:Number "," << 1833 RefType = 1; 1834 FId = _STOFID(F4->getText(), F4->getLine()); 1835 >> 1836 ) 1837 } 1838 << 1839 switch (RefType) { 1840 case 5: 1841 { 1842 R5Obj = new CIfrRef5; 1843 QHObj = R5Obj; 1844 OHObj = R5Obj; 1845 R5Obj->SetLineNo(G->getLine()); 1846 break; 1847 } 1848 case 4: 1849 { 1850 R4Obj = new CIfrRef4; 1851 QHObj = R4Obj; 1852 OHObj = R4Obj; 1853 R4Obj->SetLineNo(G->getLine()); 1854 R4Obj->SetDevicePath (DevPath); 1855 R4Obj->SetFormSetId (FSId); 1856 R4Obj->SetFormId (FId); 1857 R4Obj->SetQuestionId (QId); 1858 break; 1859 } 1860 case 3: 1861 { 1862 R3Obj = new CIfrRef3; 1863 QHObj = R3Obj; 1864 OHObj = R3Obj; 1865 R3Obj->SetLineNo(G->getLine()); 1866 R3Obj->SetFormSetId (FSId); 1867 R3Obj->SetFormId (FId); 1868 R3Obj->SetQuestionId (QId); 1869 break; 1870 } 1871 case 2: 1872 { 1873 R2Obj = new CIfrRef2; 1874 QHObj = R2Obj; 1875 OHObj = R2Obj; 1876 R2Obj->SetLineNo(G->getLine()); 1877 R2Obj->SetFormId (FId); 1878 R2Obj->SetQuestionId (QId); 1879 break; 1880 } 1881 case 1: 1882 { 1883 R1Obj = new CIfrRef; 1884 QHObj = R1Obj; 1885 OHObj = R1Obj; 1886 R1Obj->SetLineNo(G->getLine()); 1887 R1Obj->SetFormId (FId); 1888 break; 1889 } 1890 default: break; 1891 } 1892 >> 1893 vfrQuestionHeader[*QHObj, QUESTION_REF] << 1894 if (_GET_CURRQEST_DATATYPE() == EFI_IFR_TYPE_OTHER) { 1895 _GET_CURRQEST_VARTINFO().mVarType = EFI_IFR_TYPE_REF; 1896 } 1897 >> 1898 { "," F:FLAGS "=" vfrGotoFlags[QHObj, F->getLine()] } 1899 { 1900 "," Key "=" KN:Number << AssignQuestionKey (*QHObj, KN); >> 1901 } 1902 { 1903 E:"," 1904 vfrStatementQuestionOptionList << OHObj->SetScope(1); CRT_END_OP (E);>> 1905 } 1906 ";" << 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;}>> 1907 ; 1908 1909vfrGotoFlags [CIfrQuestionHeader *QHObj, UINT32 LineNum] : 1910 << UINT8 HFlags = 0; >> 1911 gotoFlagsField[HFlags] ( "\|" gotoFlagsField[HFlags] )* 1912 << _PCATCH(QHObj->SetFlags (HFlags), LineNum); >> 1913 ; 1914 1915gotoFlagsField[UINT8 & HFlags] : 1916 N:Number << _PCATCH(_STOU8(N->getText(), N->getLine()) == 0 ? VFR_RETURN_SUCCESS : VFR_RETURN_UNSUPPORTED, N->getLine()); >> 1917 | questionheaderFlagsField[HFlags] 1918 ; 1919 1920getStringId : 1921 "STRING_TOKEN" "\(" 1922 IdVal:Number 1923 "\)" 1924 ; 1925 1926vfrStatementResetButton : 1927 << 1928 CIfrResetButton RBObj; 1929 UINT16 DefaultId; 1930 >> 1931 L:ResetButton << RBObj.SetLineNo(L->getLine()); >> 1932 DefaultStore 1933 "=" N:StringIdentifier "," << 1934 _PCATCH(mCVfrDefaultStore.GetDefaultId (N->getText(), &DefaultId), N->getLine()); 1935 RBObj.SetDefaultId (DefaultId); 1936 >> 1937 vfrStatementHeader[&RBObj] "," 1938 { vfrStatementStatTagList "," } 1939 E:EndResetButton << CRT_END_OP (E); >> 1940 ";" 1941 ; 1942 1943vfrStatementBooleanType : 1944 vfrStatementCheckBox | 1945 vfrStatementAction 1946 ; 1947 1948//***************************************************** 1949// Syntax of checkbox 1950// 1951// Example: 1952// checkbox 1953// varid = MySTestData.mField1, 1954// prompt = STRING_TOKEN(STR_CHECK_BOX_PROMPT), 1955// help = STRING_TOKEN(STR_CHECK_BOX_HELP), 1956// flags = CHECKBOX_DEFAULT | CALLBACK, 1957// default value = TRUE, defaultstore = MyDefaultStore, 1958// endcheckbox; 1959// 1960vfrStatementCheckBox : 1961 << 1962 CIfrCheckBox CBObj; 1963 EFI_IFR_TYPE_VALUE Val = gZeroEfiIfrTypeValue; 1964 CHAR8 *VarStoreName = NULL; 1965 UINT32 DataTypeSize; 1966 EFI_GUID *VarStoreGuid = NULL; 1967 >> 1968 L:CheckBox << CBObj.SetLineNo(L->getLine()); >> 1969 vfrQuestionHeader[CBObj] "," << //check data type 1970 if (_GET_CURRQEST_DATATYPE() == EFI_IFR_TYPE_OTHER) { 1971 _GET_CURRQEST_VARTINFO().mVarType = EFI_IFR_TYPE_BOOLEAN; 1972 } 1973 if (_GET_CURRQEST_VARTINFO().mVarStoreId != EFI_VARSTORE_ID_INVALID) { 1974 _PCATCH (gCVfrVarDataTypeDB.GetDataTypeSize (_GET_CURRQEST_DATATYPE(), &DataTypeSize), L->getLine(), "CheckBox varid is not the valid data type"); 1975 if (DataTypeSize != 0 && DataTypeSize != _GET_CURRQEST_VARSIZE()) { 1976 _PCATCH (VFR_RETURN_INVALID_PARAMETER, L->getLine(), "CheckBox varid doesn't support array"); 1977 } else if ((mCVfrDataStorage.GetVarStoreType (_GET_CURRQEST_VARTINFO().mVarStoreId) == EFI_VFR_VARSTORE_BUFFER) && 1978 (_GET_CURRQEST_VARSIZE() != sizeof (BOOLEAN))) { 1979 _PCATCH (VFR_RETURN_INVALID_PARAMETER, L->getLine(), "CheckBox varid only support BOOLEAN data type"); 1980 } 1981 } 1982 >> 1983 { 1984 F:FLAGS "=" vfrCheckBoxFlags[CBObj, F->getLine()] "," 1985 << 1986 if (_GET_CURRQEST_VARTINFO().mVarStoreId != EFI_VARSTORE_ID_INVALID) { 1987 _PCATCH(mCVfrDataStorage.GetVarStoreName (_GET_CURRQEST_VARTINFO().mVarStoreId, &VarStoreName), VFR_RETURN_SUCCESS, L, "Failed to retrieve varstore name"); 1988 VarStoreGuid = mCVfrDataStorage.GetVarStoreGuid(_GET_CURRQEST_VARTINFO().mVarStoreId); 1989 Val.b = TRUE; 1990 if (CBObj.GetFlags () & 0x01) { 1991 CheckDuplicateDefaultValue (EFI_HII_DEFAULT_CLASS_STANDARD, F); 1992 _PCATCH( 1993 mCVfrDefaultStore.BufferVarStoreAltConfigAdd ( 1994 EFI_HII_DEFAULT_CLASS_STANDARD, 1995 _GET_CURRQEST_VARTINFO(), 1996 VarStoreName, 1997 VarStoreGuid, 1998 _GET_CURRQEST_DATATYPE (), 1999 Val 2000 ), 2001 VFR_RETURN_SUCCESS, 2002 L, 2003 "No standard default storage found" 2004 ); 2005 } 2006 if (CBObj.GetFlags () & 0x02) { 2007 CheckDuplicateDefaultValue (EFI_HII_DEFAULT_CLASS_MANUFACTURING, F); 2008 _PCATCH( 2009 mCVfrDefaultStore.BufferVarStoreAltConfigAdd ( 2010 EFI_HII_DEFAULT_CLASS_MANUFACTURING, 2011 _GET_CURRQEST_VARTINFO(), 2012 VarStoreName, 2013 VarStoreGuid, 2014 _GET_CURRQEST_DATATYPE (), 2015 Val 2016 ), 2017 VFR_RETURN_SUCCESS, 2018 L, 2019 "No manufacturing default storage found" 2020 ); 2021 } 2022 } 2023 >> 2024 } 2025 { 2026 Key "=" KN:Number "," << AssignQuestionKey (CBObj, KN); >> 2027 } 2028 vfrStatementQuestionOptionList 2029 E:EndCheckBox << CRT_END_OP (E); >> 2030 ";" 2031 ; 2032 2033vfrCheckBoxFlags [CIfrCheckBox & CBObj, UINT32 LineNum] : 2034 << 2035 UINT8 LFlags = 0; 2036 UINT8 HFlags = 0; 2037 >> 2038 checkboxFlagsField[LFlags, HFlags] ( "\|" checkboxFlagsField[LFlags, HFlags] )* 2039 << _PCATCH(CBObj.SetFlags (HFlags, LFlags), LineNum); >> 2040 ; 2041 2042checkboxFlagsField[UINT8 & LFlags, UINT8 & HFlags] : 2043 N:Number << 2044 if (mCompatibleMode) { 2045 // 2046 // set question flag 2047 // 2048 $LFlags |= _STOU8(N->getText(), N->getLine()); 2049 } else { 2050 _PCATCH(_STOU8(N->getText(), N->getLine()) == 0 ? VFR_RETURN_SUCCESS : VFR_RETURN_UNSUPPORTED, N->getLine()); 2051 } 2052 >> 2053 | D:"DEFAULT" << 2054 if (mCompatibleMode) { 2055 // 2056 // set question Default flag 2057 // 2058 $LFlags |= 0x01; 2059 } else { 2060 _PCATCH (VFR_RETURN_UNSUPPORTED, D); 2061 } 2062 >> 2063 | M:"MANUFACTURING" << 2064 if (mCompatibleMode) { 2065 // 2066 // set question MFG flag 2067 // 2068 $LFlags |= 0x02; 2069 } else { 2070 _PCATCH (VFR_RETURN_UNSUPPORTED, M); 2071 } 2072 >> 2073 | "CHECKBOX_DEFAULT" << $LFlags |= 0x01; >> 2074 | "CHECKBOX_DEFAULT_MFG" << $LFlags |= 0x02; >> 2075 | questionheaderFlagsField[HFlags] 2076 ; 2077 2078//***************************************************** 2079// Syntax of action 2080// 2081// Example: 2082// action 2083// prompt = STRING_TOKEN(STR_ACTION_PROMPT), 2084// help = STRING_TOKEN(STR_ACTION_HELP), 2085// flags = CALLBACK, 2086// config = STRING_TOKEN(STR_ACTION_CONFIG), 2087// endaction; 2088// 2089vfrStatementAction : 2090 << CIfrAction AObj; >> 2091 L:Action << AObj.SetLineNo(L->getLine()); >> 2092 vfrQuestionHeader[AObj] "," 2093 { F:FLAGS "=" vfrActionFlags[AObj, F->getLine()] "," } 2094 Config "=" "STRING_TOKEN" "\(" S:Number "\)" "," << AObj.SetQuestionConfig (_STOSID(S->getText(), S->getLine())); >> 2095 vfrStatementQuestionTagList 2096 E:EndAction << CRT_END_OP (E); >> 2097 ";" 2098 ; 2099 2100vfrActionFlags[CIfrAction & AObj, UINT32 LineNum] : 2101 << UINT8 HFlags = 0; >> 2102 actionFlagsField[HFlags] ( "\|" actionFlagsField[HFlags] )* 2103 << _PCATCH(AObj.SetFlags (HFlags), LineNum); >> 2104 ; 2105 2106actionFlagsField[UINT8 & HFlags] : 2107 N:Number << _PCATCH(_STOU8(N->getText(), N->getLine()) == 0 ? VFR_RETURN_SUCCESS : VFR_RETURN_UNSUPPORTED, N->getLine()); >> 2108 | questionheaderFlagsField[HFlags] 2109 ; 2110 2111vfrStatementDate : 2112 << 2113 EFI_QUESTION_ID QId = EFI_QUESTION_ID_INVALID; 2114 CHAR8 *VarIdStr[3] = {NULL, }; 2115 CIfrDate DObj; 2116 EFI_IFR_TYPE_VALUE Val = gZeroEfiIfrTypeValue; 2117 UINT8 Size = OFFSET_OF (EFI_IFR_DEFAULT, Value) + sizeof (EFI_HII_DATE); 2118 >> 2119 L:Date << DObj.SetLineNo(L->getLine()); >> 2120 ( 2121 ( 2122 vfrQuestionHeader[DObj, QUESTION_DATE] "," << 2123 if (_GET_CURRQEST_DATATYPE() == EFI_IFR_TYPE_OTHER) { 2124 _GET_CURRQEST_VARTINFO().mVarType = EFI_IFR_TYPE_DATE; 2125 } 2126 >> 2127 { F:FLAGS "=" vfrDateFlags[DObj, F->getLine()] "," } 2128 vfrStatementQuestionOptionList 2129 ) 2130 | 2131 ( 2132 Year VarId "=" D1:StringIdentifier "." D1Y:StringIdentifier "," 2133 << _STRCAT(&VarIdStr[0], D1->getText()); _STRCAT(&VarIdStr[0], "."); _STRCAT(&VarIdStr[0], D1Y->getText()); >> 2134 Prompt "=" "STRING_TOKEN" "\(" YP:Number "\)" "," 2135 Help "=" "STRING_TOKEN" "\(" YH:Number "\)" "," 2136 minMaxDateStepDefault[Val.date, 0] 2137 2138 Month VarId "=" D2:StringIdentifier "." D2M:StringIdentifier "," 2139 << _STRCAT(&VarIdStr[1], D2->getText()); _STRCAT(&VarIdStr[1], "."); _STRCAT(&VarIdStr[1], D2M->getText()); >> 2140 Prompt "=" "STRING_TOKEN" "\(" MP:Number "\)" "," 2141 Help "=" "STRING_TOKEN" "\(" MH:Number "\)" "," 2142 minMaxDateStepDefault[Val.date, 1] 2143 2144 Day VarId "=" D3:StringIdentifier "." D3D:StringIdentifier "," 2145 << _STRCAT(&VarIdStr[2], D3->getText()); _STRCAT(&VarIdStr[2], "."); _STRCAT(&VarIdStr[2], D3D->getText()); >> 2146 Prompt "=" "STRING_TOKEN" "\(" DP:Number "\)" "," 2147 Help "=" "STRING_TOKEN" "\(" DH:Number "\)" "," 2148 minMaxDateStepDefault[Val.date, 2] 2149 { G:FLAGS "=" vfrDateFlags[DObj, G->getLine()] "," } 2150 << 2151 mCVfrQuestionDB.RegisterOldDateQuestion (VarIdStr[0], VarIdStr[1], VarIdStr[2], QId); 2152 DObj.SetQuestionId (QId); 2153 DObj.SetFlags (EFI_IFR_QUESTION_FLAG_DEFAULT, QF_DATE_STORAGE_TIME); 2154 DObj.SetPrompt (_STOSID(YP->getText(), YP->getLine())); 2155 DObj.SetHelp (_STOSID(YH->getText(), YH->getLine())); 2156 if (VarIdStr[0] != NULL) { delete VarIdStr[0]; } if (VarIdStr[1] != NULL) { delete VarIdStr[1]; } if (VarIdStr[2] != NULL) { delete VarIdStr[2]; } 2157 >> 2158 << {CIfrDefault DefaultObj(Size, EFI_HII_DEFAULT_CLASS_STANDARD, EFI_IFR_TYPE_DATE, Val); DefaultObj.SetLineNo(L->getLine());} >> 2159 ) 2160 ( vfrStatementInconsistentIf )* 2161 ) 2162 E:EndDate << CRT_END_OP (E); >> 2163 ";" 2164 ; 2165 2166minMaxDateStepDefault[EFI_HII_DATE & D, UINT8 KeyValue] : 2167 Minimum "=" MinN:Number "," 2168 Maximum "=" MaxN:Number "," 2169 { "step" "=" Number "," } 2170 { 2171 "default" "=" N:Number "," << 2172 switch (KeyValue) { 2173 case 0: 2174 D.Year = _STOU16(N->getText(), N->getLine()); 2175 if (D.Year < _STOU16 (MinN->getText(), MinN->getLine()) || D.Year > _STOU16 (MaxN->getText(), MaxN->getLine())) { 2176 _PCATCH (VFR_RETURN_INVALID_PARAMETER, N->getLine(), "Year default value must be between Min year and Max year."); 2177 } 2178 break; 2179 case 1: 2180 D.Month = _STOU8(N->getText(), N->getLine()); 2181 if (D.Month < 1 || D.Month > 12) { 2182 _PCATCH (VFR_RETURN_INVALID_PARAMETER, N->getLine(), "Month default value must be between 1 and 12."); 2183 } 2184 break; 2185 case 2: 2186 D.Day = _STOU8(N->getText(), N->getLine()); 2187 if (D.Day < 1 || D.Day > 31) { 2188 _PCATCH (VFR_RETURN_INVALID_PARAMETER, N->getLine(), "Day default value must be between 1 and 31."); 2189 } 2190 break; 2191 } 2192 >> 2193 } 2194 ; 2195 2196vfrDateFlags [CIfrDate & DObj, UINT32 LineNum] : 2197 << UINT8 LFlags = 0; >> 2198 dateFlagsField[LFlags] ( "\|" dateFlagsField[LFlags] )* 2199 << _PCATCH(DObj.SetFlags (EFI_IFR_QUESTION_FLAG_DEFAULT, LFlags), LineNum); >> 2200 ; 2201 2202dateFlagsField [UINT8 & Flags] : 2203 N:Number << $Flags |= _STOU8(N->getText(), N->getLine()); >> 2204 | "YEAR_SUPPRESS" << $Flags |= 0x01; >> 2205 | "MONTH_SUPPRESS" << $Flags |= 0x02; >> 2206 | "DAY_SUPPRESS" << $Flags |= 0x04; >> 2207 | "STORAGE_NORMAL" << $Flags |= 0x00; >> 2208 | "STORAGE_TIME" << $Flags |= 0x10; >> 2209 | "STORAGE_WAKEUP" << $Flags |= 0x20; >> 2210 ; 2211 2212vfrStatementNumericType : 2213 vfrStatementNumeric | 2214 vfrStatementOneOf 2215 ; 2216 2217vfrSetMinMaxStep[CIfrMinMaxStepData & MMSDObj] : 2218 << 2219 UINT64 MaxU8 = 0, MinU8 = 0, StepU8 = 0; 2220 UINT32 MaxU4 = 0, MinU4 = 0, StepU4 = 0; 2221 UINT16 MaxU2 = 0, MinU2 = 0, StepU2 = 0; 2222 UINT8 MaxU1 = 0, MinU1 = 0, StepU1 = 0; 2223 >> 2224 Minimum "=" I:Number "," 2225 << 2226 switch (_GET_CURRQEST_DATATYPE()) { 2227 case EFI_IFR_TYPE_NUM_SIZE_64 : MinU8 = _STOU64(I->getText(), I->getLine()); break; 2228 case EFI_IFR_TYPE_NUM_SIZE_32 : MinU4 = _STOU32(I->getText(), I->getLine()); break; 2229 case EFI_IFR_TYPE_NUM_SIZE_16 : MinU2 = _STOU16(I->getText(), I->getLine()); break; 2230 case EFI_IFR_TYPE_NUM_SIZE_8 : MinU1 = _STOU8(I->getText(), I->getLine()); break; 2231 } 2232 >> 2233 Maximum "=" A:Number "," 2234 << 2235 switch (_GET_CURRQEST_DATATYPE()) { 2236 case EFI_IFR_TYPE_NUM_SIZE_64 : 2237 MaxU8 = _STOU64(A->getText(), A->getLine()); 2238 if (MaxU8 < MinU8) { 2239 _PCATCH (VFR_RETURN_INVALID_PARAMETER, A->getLine(), "Maximum can't be less than Minimum"); 2240 } 2241 break; 2242 case EFI_IFR_TYPE_NUM_SIZE_32 : 2243 MaxU4 = _STOU32(A->getText(), A->getLine()); 2244 if (MaxU4 < MinU4) { 2245 _PCATCH (VFR_RETURN_INVALID_PARAMETER, A->getLine(), "Maximum can't be less than Minimum"); 2246 } 2247 break; 2248 case EFI_IFR_TYPE_NUM_SIZE_16 : 2249 MaxU2 = _STOU16(A->getText(), A->getLine()); 2250 if (MaxU2 < MinU2) { 2251 _PCATCH (VFR_RETURN_INVALID_PARAMETER, A->getLine(), "Maximum can't be less than Minimum"); 2252 } 2253 break; 2254 case EFI_IFR_TYPE_NUM_SIZE_8 : 2255 MaxU1 = _STOU8(A->getText(), A->getLine()); 2256 if (MaxU1 < MinU1) { 2257 _PCATCH (VFR_RETURN_INVALID_PARAMETER, A->getLine(), "Maximum can't be less than Minimum"); 2258 } 2259 break; 2260 } 2261 >> 2262 { 2263 STEP "=" S:Number "," 2264 << 2265 switch (_GET_CURRQEST_DATATYPE()) { 2266 case EFI_IFR_TYPE_NUM_SIZE_64 : StepU8 = _STOU64(S->getText(), S->getLine()); break; 2267 case EFI_IFR_TYPE_NUM_SIZE_32 : StepU4 = _STOU32(S->getText(), S->getLine()); break; 2268 case EFI_IFR_TYPE_NUM_SIZE_16 : StepU2 = _STOU16(S->getText(), S->getLine()); break; 2269 case EFI_IFR_TYPE_NUM_SIZE_8 : StepU1 = _STOU8(S->getText(), S->getLine()); break; 2270 } 2271 >> 2272 } 2273 << 2274 switch (_GET_CURRQEST_DATATYPE()) { 2275 case EFI_IFR_TYPE_NUM_SIZE_64 : $MMSDObj.SetMinMaxStepData (MinU8, MaxU8, StepU8); break; 2276 case EFI_IFR_TYPE_NUM_SIZE_32 : $MMSDObj.SetMinMaxStepData (MinU4, MaxU4, StepU4); break; 2277 case EFI_IFR_TYPE_NUM_SIZE_16 : $MMSDObj.SetMinMaxStepData (MinU2, MaxU2, StepU2); break; 2278 case EFI_IFR_TYPE_NUM_SIZE_8 : $MMSDObj.SetMinMaxStepData (MinU1, MaxU1, StepU1); break; 2279 } 2280 >> 2281 ; 2282 2283vfrStatementNumeric : 2284 << 2285 CIfrNumeric NObj; 2286 UINT32 DataTypeSize; 2287 BOOLEAN IsSupported = TRUE; 2288 UINT8 ShrinkSize = 0; 2289 >> 2290 L:Numeric << NObj.SetLineNo(L->getLine()); >> 2291 vfrQuestionHeader[NObj] "," << // check data type 2292 if (_GET_CURRQEST_VARTINFO().mVarStoreId != EFI_VARSTORE_ID_INVALID) { 2293 _PCATCH (gCVfrVarDataTypeDB.GetDataTypeSize (_GET_CURRQEST_DATATYPE(), &DataTypeSize), L->getLine(), "Numeric varid is not the valid data type"); 2294 if (DataTypeSize != 0 && DataTypeSize != _GET_CURRQEST_VARSIZE()) { 2295 _PCATCH (VFR_RETURN_INVALID_PARAMETER, L->getLine(), "Numeric varid doesn't support array"); 2296 } 2297 _PCATCH(NObj.SetFlags (NObj.FLAGS(), _GET_CURRQEST_DATATYPE()), L->getLine()); 2298 } 2299 >> 2300 { F:FLAGS "=" vfrNumericFlags[NObj, F->getLine()] "," } 2301 { 2302 Key "=" KN:Number "," << AssignQuestionKey (NObj, KN); >> 2303 } 2304 vfrSetMinMaxStep[NObj] << 2305 switch (_GET_CURRQEST_DATATYPE()) { 2306 // 2307 // Base on the type to know the actual used size,shrink the buffer 2308 // size allocate before. 2309 // 2310 case EFI_IFR_TYPE_NUM_SIZE_8: ShrinkSize = 21;break; 2311 case EFI_IFR_TYPE_NUM_SIZE_16:ShrinkSize = 18;break; 2312 case EFI_IFR_TYPE_NUM_SIZE_32:ShrinkSize = 12;break; 2313 case EFI_IFR_TYPE_NUM_SIZE_64:break; 2314 default: 2315 IsSupported = FALSE; 2316 break; 2317 } 2318 NObj.ShrinkBinSize (ShrinkSize); 2319 if (!IsSupported) { 2320 _PCATCH (VFR_RETURN_INVALID_PARAMETER, L->getLine(), "Numeric question only support UINT8, UINT16, UINT32 and UINT64 data type."); 2321 } 2322 >> 2323 vfrStatementQuestionOptionList 2324 E:EndNumeric << 2325 CRT_END_OP (E); 2326 >> 2327 ";" 2328 ; 2329 2330vfrNumericFlags [CIfrNumeric & NObj, UINT32 LineNum] : 2331 << 2332 UINT8 LFlags = _GET_CURRQEST_DATATYPE() & EFI_IFR_NUMERIC_SIZE; 2333 UINT8 HFlags = 0; 2334 EFI_VFR_VARSTORE_TYPE VarStoreType = EFI_VFR_VARSTORE_INVALID; 2335 BOOLEAN IsSetType = FALSE; 2336 BOOLEAN IsDisplaySpecified = FALSE; 2337 >> 2338 numericFlagsField[HFlags, LFlags, IsSetType, IsDisplaySpecified] ( "\|" numericFlagsField[HFlags, LFlags, IsSetType, IsDisplaySpecified ] )* 2339 << 2340 //check data type flag 2341 if (_GET_CURRQEST_VARTINFO().mVarStoreId != EFI_VARSTORE_ID_INVALID) { 2342 VarStoreType = mCVfrDataStorage.GetVarStoreType (_GET_CURRQEST_VARTINFO().mVarStoreId); 2343 if (VarStoreType == EFI_VFR_VARSTORE_BUFFER || VarStoreType == EFI_VFR_VARSTORE_EFI) { 2344 if (_GET_CURRQEST_DATATYPE() != (LFlags & EFI_IFR_NUMERIC_SIZE)) { 2345 _PCATCH(VFR_RETURN_INVALID_PARAMETER, LineNum, "Numeric Flag is not same to Numeric VarData type"); 2346 } 2347 } else { 2348 // update data type for name/value store 2349 UINT32 DataTypeSize; 2350 _GET_CURRQEST_VARTINFO().mVarType = LFlags & EFI_IFR_NUMERIC_SIZE; 2351 gCVfrVarDataTypeDB.GetDataTypeSize (_GET_CURRQEST_DATATYPE(), &DataTypeSize); 2352 _GET_CURRQEST_VARTINFO().mVarTotalSize = DataTypeSize; 2353 } 2354 } else if (IsSetType){ 2355 _GET_CURRQEST_VARTINFO().mVarType = LFlags & EFI_IFR_NUMERIC_SIZE; 2356 } 2357 _PCATCH(NObj.SetFlags (HFlags, LFlags, IsDisplaySpecified), LineNum); 2358 >> 2359 ; 2360 2361numericFlagsField [UINT8 & HFlags, UINT8 & LFlags, BOOLEAN & IsSetType, BOOLEAN & IsDisplaySpecified] : 2362 N:Number << _PCATCH(_STOU8(N->getText(), N->getLine()) == 0 ? VFR_RETURN_SUCCESS : VFR_RETURN_UNSUPPORTED, N->getLine()); >> 2363 | "NUMERIC_SIZE_1" << $LFlags = ($LFlags & ~EFI_IFR_NUMERIC_SIZE) | EFI_IFR_NUMERIC_SIZE_1; IsSetType = TRUE;>> 2364 | "NUMERIC_SIZE_2" << $LFlags = ($LFlags & ~EFI_IFR_NUMERIC_SIZE) | EFI_IFR_NUMERIC_SIZE_2; IsSetType = TRUE;>> 2365 | "NUMERIC_SIZE_4" << $LFlags = ($LFlags & ~EFI_IFR_NUMERIC_SIZE) | EFI_IFR_NUMERIC_SIZE_4; IsSetType = TRUE;>> 2366 | "NUMERIC_SIZE_8" << $LFlags = ($LFlags & ~EFI_IFR_NUMERIC_SIZE) | EFI_IFR_NUMERIC_SIZE_8; IsSetType = TRUE;>> 2367 | "DISPLAY_INT_DEC" << $LFlags = ($LFlags & ~EFI_IFR_DISPLAY) | EFI_IFR_DISPLAY_INT_DEC; IsDisplaySpecified = TRUE;>> 2368 | "DISPLAY_UINT_DEC" << $LFlags = ($LFlags & ~EFI_IFR_DISPLAY) | EFI_IFR_DISPLAY_UINT_DEC; IsDisplaySpecified = TRUE;>> 2369 | "DISPLAY_UINT_HEX" << $LFlags = ($LFlags & ~EFI_IFR_DISPLAY) | EFI_IFR_DISPLAY_UINT_HEX; IsDisplaySpecified = TRUE;>> 2370 | questionheaderFlagsField[HFlags] 2371 ; 2372 2373vfrStatementOneOf : 2374 << 2375 CIfrOneOf OObj; 2376 UINT32 DataTypeSize; 2377 BOOLEAN IsSupported = TRUE; 2378 UINT8 ShrinkSize = 0; 2379 >> 2380 L:OneOf << OObj.SetLineNo(L->getLine()); >> 2381 vfrQuestionHeader[OObj] "," << //check data type 2382 if (_GET_CURRQEST_VARTINFO().mVarStoreId != EFI_VARSTORE_ID_INVALID) { 2383 _PCATCH (gCVfrVarDataTypeDB.GetDataTypeSize (_GET_CURRQEST_DATATYPE(), &DataTypeSize), L->getLine(), "OneOf varid is not the valid data type"); 2384 if (DataTypeSize != 0 && DataTypeSize != _GET_CURRQEST_VARSIZE()) { 2385 _PCATCH (VFR_RETURN_INVALID_PARAMETER, L->getLine(), "OneOf varid doesn't support array"); 2386 } 2387 _PCATCH(OObj.SetFlags (OObj.FLAGS(), _GET_CURRQEST_DATATYPE()), L->getLine()); 2388 } 2389 >> 2390 { F:FLAGS "=" vfrOneofFlagsField[OObj, F->getLine()] "," } 2391 { 2392 vfrSetMinMaxStep[OObj] 2393 } 2394 << 2395 switch (_GET_CURRQEST_DATATYPE()) { 2396 // 2397 // Base on the type to know the actual used size,shrink the buffer 2398 // size allocate before. 2399 // 2400 case EFI_IFR_TYPE_NUM_SIZE_8: ShrinkSize = 21;break; 2401 case EFI_IFR_TYPE_NUM_SIZE_16:ShrinkSize = 18;break; 2402 case EFI_IFR_TYPE_NUM_SIZE_32:ShrinkSize = 12;break; 2403 case EFI_IFR_TYPE_NUM_SIZE_64:break; 2404 default: 2405 IsSupported = FALSE; 2406 break; 2407 } 2408 OObj.ShrinkBinSize (ShrinkSize); 2409 if (!IsSupported) { 2410 _PCATCH (VFR_RETURN_INVALID_PARAMETER, L->getLine(), "OneOf question only support UINT8, UINT16, UINT32 and UINT64 data type."); 2411 } 2412 >> 2413 vfrStatementQuestionOptionList 2414 E:EndOneOf << 2415 CRT_END_OP (E); 2416 >> 2417 ";" 2418 ; 2419 2420vfrOneofFlagsField [CIfrOneOf & OObj, UINT32 LineNum] : 2421 << 2422 UINT8 LFlags = _GET_CURRQEST_DATATYPE() & EFI_IFR_NUMERIC_SIZE; 2423 UINT8 HFlags = 0; 2424 EFI_VFR_VARSTORE_TYPE VarStoreType = EFI_VFR_VARSTORE_INVALID; 2425 BOOLEAN IsSetType = FALSE; 2426 BOOLEAN IsDisplaySpecified = FALSE; 2427 >> 2428 numericFlagsField[HFlags, LFlags, IsSetType, IsDisplaySpecified] ( "\|" numericFlagsField[HFlags, LFlags, IsSetType, IsDisplaySpecified] )* 2429 << 2430 //check data type flag 2431 if (_GET_CURRQEST_VARTINFO().mVarStoreId != EFI_VARSTORE_ID_INVALID) { 2432 VarStoreType = mCVfrDataStorage.GetVarStoreType (_GET_CURRQEST_VARTINFO().mVarStoreId); 2433 if (VarStoreType == EFI_VFR_VARSTORE_BUFFER || VarStoreType == EFI_VFR_VARSTORE_EFI) { 2434 if (_GET_CURRQEST_DATATYPE() != (LFlags & EFI_IFR_NUMERIC_SIZE)) { 2435 _PCATCH(VFR_RETURN_INVALID_PARAMETER, LineNum, "Numeric Flag is not same to Numeric VarData type"); 2436 } 2437 } else { 2438 // update data type for Name/Value store 2439 UINT32 DataTypeSize; 2440 _GET_CURRQEST_VARTINFO().mVarType = LFlags & EFI_IFR_NUMERIC_SIZE; 2441 gCVfrVarDataTypeDB.GetDataTypeSize (_GET_CURRQEST_DATATYPE(), &DataTypeSize); 2442 _GET_CURRQEST_VARTINFO().mVarTotalSize = DataTypeSize; 2443 } 2444 } else if (IsSetType){ 2445 _GET_CURRQEST_VARTINFO().mVarType = LFlags & EFI_IFR_NUMERIC_SIZE; 2446 } 2447 _PCATCH(OObj.SetFlags (HFlags, LFlags), LineNum); 2448 >> 2449 ; 2450 2451vfrStatementStringType : 2452 vfrStatementString | 2453 vfrStatementPassword 2454 ; 2455 2456vfrStatementString : 2457 << 2458 CIfrString SObj; 2459 UINT32 VarArraySize; 2460 UINT8 StringMinSize; 2461 UINT8 StringMaxSize; 2462 >> 2463 L:String << SObj.SetLineNo(L->getLine()); >> 2464 vfrQuestionHeader[SObj] "," 2465 { F:FLAGS "=" vfrStringFlagsField[SObj, F->getLine()] "," } 2466 { 2467 Key "=" KN:Number "," << AssignQuestionKey (SObj, KN); >> 2468 } 2469 MinSize "=" MIN:Number "," << 2470 VarArraySize = _GET_CURRQEST_ARRAY_SIZE(); 2471 StringMinSize = _STOU8(MIN->getText(), MIN->getLine()); 2472 if (_STOU64(MIN->getText(), MIN->getLine()) > StringMinSize) { 2473 _PCATCH (VFR_RETURN_INVALID_PARAMETER, MIN->getLine(), "String MinSize takes only one byte, which can't be larger than 0xFF."); 2474 } else if (VarArraySize != 0 && StringMinSize > VarArraySize) { 2475 _PCATCH (VFR_RETURN_INVALID_PARAMETER, MIN->getLine(), "String MinSize can't be larger than the max number of elements in string array."); 2476 } 2477 SObj.SetMinSize (StringMinSize); 2478 >> 2479 MaxSize "=" MAX:Number "," << 2480 StringMaxSize = _STOU8(MAX->getText(), MAX->getLine()); 2481 if (_STOU64(MAX->getText(), MAX->getLine()) > StringMaxSize) { 2482 _PCATCH (VFR_RETURN_INVALID_PARAMETER, MAX->getLine(), "String MaxSize takes only one byte, which can't be larger than 0xFF."); 2483 } else if (VarArraySize != 0 && StringMaxSize > VarArraySize) { 2484 _PCATCH (VFR_RETURN_INVALID_PARAMETER, MAX->getLine(), "String MaxSize can't be larger than the max number of elements in string array."); 2485 } else if (StringMaxSize < StringMinSize) { 2486 _PCATCH (VFR_RETURN_INVALID_PARAMETER, MAX->getLine(), "String MaxSize can't be less than String MinSize."); 2487 } 2488 SObj.SetMaxSize (StringMaxSize); 2489 >> 2490 vfrStatementQuestionOptionList 2491 E:EndString << CRT_END_OP (E); >> 2492 ";" 2493 ; 2494 2495vfrStringFlagsField [CIfrString & SObj, UINT32 LineNum] : 2496 << 2497 UINT8 LFlags = 0; 2498 UINT8 HFlags = 0; 2499 >> 2500 stringFlagsField[HFlags, LFlags] ( "\|" stringFlagsField[HFlags, LFlags] )* 2501 << _PCATCH(SObj.SetFlags (HFlags, LFlags), LineNum); >> 2502 ; 2503 2504stringFlagsField [UINT8 & HFlags, UINT8 & LFlags] : 2505 N:Number << _PCATCH(_STOU8(N->getText(), N->getLine()) == 0 ? VFR_RETURN_SUCCESS : VFR_RETURN_UNSUPPORTED, N->getLine()); >> 2506 | "MULTI_LINE" << $LFlags = 0x01; >> 2507 | questionheaderFlagsField[HFlags] 2508 ; 2509 2510vfrStatementPassword : 2511 << 2512 CIfrPassword PObj; 2513 UINT32 VarArraySize; 2514 UINT16 PasswordMinSize; 2515 UINT16 PasswordMaxSize; 2516 >> 2517 L:Password << PObj.SetLineNo(L->getLine()); >> 2518 vfrQuestionHeader[PObj] "," 2519 { F:FLAGS "=" vfrPasswordFlagsField[PObj, F->getLine()] "," } 2520 { 2521 Key "=" KN:Number "," << AssignQuestionKey (PObj, KN); >> 2522 } 2523 MinSize "=" MIN:Number "," << 2524 VarArraySize = _GET_CURRQEST_ARRAY_SIZE(); 2525 PasswordMinSize = _STOU16(MIN->getText(), MIN->getLine()); 2526 if (_STOU64(MIN->getText(), MIN->getLine()) > PasswordMinSize) { 2527 _PCATCH (VFR_RETURN_INVALID_PARAMETER, MIN->getLine(), "Password MinSize takes only two byte, which can't be larger than 0xFFFF."); 2528 } else if (VarArraySize != 0 && PasswordMinSize > VarArraySize) { 2529 _PCATCH (VFR_RETURN_INVALID_PARAMETER, MIN->getLine(), "Password MinSize can't be larger than the max number of elements in password array."); 2530 } 2531 PObj.SetMinSize (PasswordMinSize); 2532 >> 2533 MaxSize "=" MAX:Number "," << 2534 PasswordMaxSize = _STOU16(MAX->getText(), MAX->getLine()); 2535 if (_STOU64(MAX->getText(), MAX->getLine()) > PasswordMaxSize) { 2536 _PCATCH (VFR_RETURN_INVALID_PARAMETER, MAX->getLine(), "Password MaxSize takes only two byte, which can't be larger than 0xFFFF."); 2537 } else if (VarArraySize != 0 && PasswordMaxSize > VarArraySize) { 2538 _PCATCH (VFR_RETURN_INVALID_PARAMETER, MAX->getLine(), "Password MaxSize can't be larger than the max number of elements in password array."); 2539 } else if (PasswordMaxSize < PasswordMinSize) { 2540 _PCATCH (VFR_RETURN_INVALID_PARAMETER, MAX->getLine(), "Password MaxSize can't be less than Password MinSize."); 2541 } 2542 PObj.SetMaxSize (PasswordMaxSize); 2543 >> 2544 { Encoding "=" Number "," } 2545 vfrStatementQuestionOptionList 2546 E:EndPassword << CRT_END_OP (E); >> 2547 ";" 2548 ; 2549 2550vfrPasswordFlagsField [CIfrPassword & PObj, UINT32 LineNum] : 2551 << UINT8 HFlags = 0; >> 2552 passwordFlagsField[HFlags] ( "\|" passwordFlagsField[HFlags] )* 2553 << _PCATCH(PObj.SetFlags(HFlags), LineNum); >> 2554 ; 2555 2556passwordFlagsField [UINT8 & HFlags] : 2557 N:Number << _PCATCH(_STOU8(N->getText(), N->getLine()) == 0 ? VFR_RETURN_SUCCESS : VFR_RETURN_UNSUPPORTED, N->getLine()); >> 2558 | questionheaderFlagsField[HFlags] 2559 ; 2560 2561vfrStatementOrderedList : 2562 << 2563 CIfrOrderedList OLObj; 2564 UINT32 VarArraySize; 2565 >> 2566 L:OrderedList << OLObj.SetLineNo(L->getLine()); >> 2567 vfrQuestionHeader[OLObj] "," 2568 << 2569 VarArraySize = _GET_CURRQEST_ARRAY_SIZE(); 2570 OLObj.SetMaxContainers ((UINT8) (VarArraySize > 0xFF ? 0xFF : VarArraySize)); 2571 >> 2572 { 2573 MaxContainers "=" M:Number "," << 2574 if (_STOU64(M->getText(), M->getLine()) > _STOU8(M->getText(), M->getLine())) { 2575 _PCATCH (VFR_RETURN_INVALID_PARAMETER, M->getLine(), "OrderedList MaxContainers takes only one byte, which can't be larger than 0xFF."); 2576 } else if (VarArraySize != 0 && _STOU8(M->getText(), M->getLine()) > VarArraySize) { 2577 _PCATCH (VFR_RETURN_INVALID_PARAMETER, M->getLine(), "OrderedList MaxContainers can't be larger than the max number of elements in array."); 2578 } 2579 OLObj.SetMaxContainers (_STOU8(M->getText(), M->getLine())); 2580 >> 2581 } 2582 { F:FLAGS "=" vfrOrderedListFlags[OLObj, F->getLine()] {","}} 2583 vfrStatementQuestionOptionList 2584 E:EndList << CRT_END_OP (E); >> 2585 ";" 2586 ; 2587 2588vfrOrderedListFlags [CIfrOrderedList & OLObj, UINT32 LineNum] : 2589 << 2590 UINT8 HFlags = 0; 2591 UINT8 LFlags = 0; 2592 >> 2593 orderedlistFlagsField[HFlags, LFlags] ( "\|" orderedlistFlagsField[HFlags, LFlags] )* 2594 << _PCATCH(OLObj.SetFlags (HFlags, LFlags), LineNum); >> 2595 ; 2596 2597orderedlistFlagsField [UINT8 & HFlags, UINT8 & LFlags] : 2598 N:Number << _PCATCH(_STOU8(N->getText(), N->getLine()) == 0 ? VFR_RETURN_SUCCESS : VFR_RETURN_UNSUPPORTED, N->getLine()); >> 2599 | "UNIQUE" << $LFlags |= 0x01; >> 2600 | "NOEMPTY" << $LFlags |= 0x02; >> 2601 | questionheaderFlagsField[HFlags] 2602 ; 2603 2604vfrStatementTime : 2605 << 2606 EFI_QUESTION_ID QId = EFI_QUESTION_ID_INVALID; 2607 CHAR8 *VarIdStr[3] = {NULL, }; 2608 CIfrTime TObj; 2609 EFI_IFR_TYPE_VALUE Val = gZeroEfiIfrTypeValue; 2610 UINT8 Size = OFFSET_OF (EFI_IFR_DEFAULT, Value) + sizeof (EFI_HII_TIME); 2611 >> 2612 L:Time << TObj.SetLineNo(L->getLine()); >> 2613 ( 2614 ( 2615 vfrQuestionHeader[TObj, QUESTION_TIME] "," << 2616 if (_GET_CURRQEST_DATATYPE() == EFI_IFR_TYPE_OTHER) { 2617 _GET_CURRQEST_VARTINFO().mVarType = EFI_IFR_TYPE_TIME; 2618 } 2619 >> 2620 { F:FLAGS "=" vfrTimeFlags[TObj, F->getLine()] "," } 2621 vfrStatementQuestionOptionList 2622 ) 2623 | 2624 ( 2625 Hour VarId "=" T1:StringIdentifier "." T1H:StringIdentifier "," 2626 << _STRCAT(&VarIdStr[0], T1->getText()); _STRCAT(&VarIdStr[0], "."); _STRCAT(&VarIdStr[0], T1H->getText()); >> 2627 Prompt "=" "STRING_TOKEN" "\(" HP:Number "\)" "," 2628 Help "=" "STRING_TOKEN" "\(" HH:Number "\)" "," 2629 minMaxTimeStepDefault[Val.time, 0] 2630 2631 Minute VarId "=" T2:StringIdentifier "." T2M:StringIdentifier "," 2632 << _STRCAT(&VarIdStr[1], T2->getText()); _STRCAT(&VarIdStr[1], "."); _STRCAT(&VarIdStr[1], T2M->getText()); >> 2633 Prompt "=" "STRING_TOKEN" "\(" MP:Number "\)" "," 2634 Help "=" "STRING_TOKEN" "\(" MH:Number "\)" "," 2635 minMaxTimeStepDefault[Val.time, 1] 2636 2637 Second VarId "=" T3:StringIdentifier "." T3S:StringIdentifier "," 2638 << _STRCAT(&VarIdStr[2], T3->getText()); _STRCAT(&VarIdStr[2], "."); _STRCAT(&VarIdStr[2], T3S->getText()); >> 2639 Prompt "=" "STRING_TOKEN" "\(" SP:Number "\)" "," 2640 Help "=" "STRING_TOKEN" "\(" SH:Number "\)" "," 2641 minMaxTimeStepDefault[Val.time, 2] 2642 { G:FLAGS "=" vfrTimeFlags[TObj, G->getLine()] "," } 2643 << 2644 mCVfrQuestionDB.RegisterOldTimeQuestion (VarIdStr[0], VarIdStr[1], VarIdStr[2], QId); 2645 TObj.SetQuestionId (QId); 2646 TObj.SetFlags (EFI_IFR_QUESTION_FLAG_DEFAULT, QF_TIME_STORAGE_TIME); 2647 TObj.SetPrompt (_STOSID(HP->getText(), HP->getLine())); 2648 TObj.SetHelp (_STOSID(HH->getText(), HH->getLine())); 2649 if (VarIdStr[0] != NULL) { delete VarIdStr[0]; } if (VarIdStr[1] != NULL) { delete VarIdStr[1]; } if (VarIdStr[2] != NULL) { delete VarIdStr[2]; } 2650 >> 2651 << {CIfrDefault DefaultObj(Size, EFI_HII_DEFAULT_CLASS_STANDARD, EFI_IFR_TYPE_TIME, Val); DefaultObj.SetLineNo(L->getLine());} >> 2652 ) 2653 ( vfrStatementInconsistentIf )* 2654 ) 2655 E:EndTime << CRT_END_OP (E); >> 2656 ";" 2657 ; 2658 2659minMaxTimeStepDefault[EFI_HII_TIME & T, UINT8 KeyValue] : 2660 Minimum "=" Number "," 2661 Maximum "=" Number "," 2662 { "step" "=" Number "," } 2663 { 2664 "default" "=" N:Number "," << 2665 switch (KeyValue) { 2666 case 0: 2667 T.Hour = _STOU8(N->getText(), N->getLine()); 2668 if (T.Hour > 23) { 2669 _PCATCH (VFR_RETURN_INVALID_PARAMETER, N->getLine(), "Hour default value must be between 0 and 23."); 2670 } 2671 break; 2672 case 1: 2673 T.Minute = _STOU8(N->getText(), N->getLine()); 2674 if (T.Minute > 59) { 2675 _PCATCH (VFR_RETURN_INVALID_PARAMETER, N->getLine(), "Minute default value must be between 0 and 59."); 2676 } 2677 break; 2678 case 2: 2679 T.Second = _STOU8(N->getText(), N->getLine()); 2680 if (T.Second > 59) { 2681 _PCATCH (VFR_RETURN_INVALID_PARAMETER, N->getLine(), "Second default value must be between 0 and 59."); 2682 } 2683 break; 2684 } 2685 >> 2686 } 2687 ; 2688 2689vfrTimeFlags [CIfrTime & TObj, UINT32 LineNum] : 2690 << UINT8 LFlags = 0; >> 2691 timeFlagsField[LFlags] ( "\|" timeFlagsField[LFlags] )* 2692 << _PCATCH(TObj.SetFlags(EFI_IFR_QUESTION_FLAG_DEFAULT, LFlags), LineNum); >> 2693 ; 2694 2695timeFlagsField [UINT8 & Flags] : 2696 N:Number << $Flags |= _STOU8(N->getText(), N->getLine()); >> 2697 | "HOUR_SUPPRESS" << $Flags |= 0x01; >> 2698 | "MINUTE_SUPPRESS" << $Flags |= 0x02; >> 2699 | "SECOND_SUPPRESS" << $Flags |= 0x04; >> 2700 | "STORAGE_NORMAL" << $Flags |= 0x00; >> 2701 | "STORAGE_TIME" << $Flags |= 0x10; >> 2702 | "STORAGE_WAKEUP" << $Flags |= 0x20; >> 2703 ; 2704 2705vfrStatementQuestionTag : 2706 vfrStatementStatTag "," | 2707 vfrStatementInconsistentIf | 2708 vfrStatementNoSubmitIf | 2709 vfrStatementDisableIfQuest | 2710 vfrStatementRefresh | 2711 vfrStatementVarstoreDevice | 2712 vfrStatementExtension | 2713 vfrStatementRefreshEvent | 2714 vfrStatementWarningIf 2715 ; 2716 2717vfrStatementQuestionTagList : 2718 ( vfrStatementQuestionTag )* 2719 ; 2720 2721vfrStatementQuestionOptionTag : 2722 vfrStatementSuppressIfQuest | 2723 vfrStatementGrayOutIfQuest | 2724 vfrStatementValue | 2725 vfrStatementDefault | 2726 vfrStatementRead | 2727 vfrStatementWrite | 2728 vfrStatementOptions 2729 ; 2730 2731vfrStatementQuestionOptionList : 2732 ( 2733 vfrStatementQuestionTag | 2734 vfrStatementQuestionOptionTag 2735 )* 2736 ; 2737 2738vfrStatementStatList : 2739 vfrStatementStat | 2740 vfrStatementQuestions | 2741 vfrStatementConditionalNew | 2742 vfrStatementLabel | 2743 vfrStatementExtension | 2744 // Just for framework vfr compatibility 2745 vfrStatementInvalid 2746 ; 2747 2748vfrStatementStatListOld : 2749 vfrStatementStat | 2750 vfrStatementQuestions | 2751 vfrStatementLabel | 2752 // Just for framework vfr compatibility 2753 vfrStatementInvalid 2754 ; 2755 2756vfrStatementDisableIfStat : 2757 << 2758 CIfrDisableIf DIObj; 2759 >> 2760 L:DisableIf << DIObj.SetLineNo(L->getLine()); >> 2761 vfrStatementExpression[0] ";" 2762 ( vfrStatementStatList )* 2763 E:EndIf << CRT_END_OP (E); >> 2764 ";" 2765 ; 2766 2767vfrStatementInconsistentIfStat : 2768 << CIfrInconsistentIf IIObj; >> 2769 L:InconsistentIf << 2770 if (!mCompatibleMode) { 2771 _PCATCH (VFR_RETURN_UNSUPPORTED, L); 2772 } 2773 IIObj.SetLineNo(L->getLine()); 2774 >> 2775 Prompt "=" "STRING_TOKEN" "\(" S:Number "\)" "," << IIObj.SetError (_STOSID(S->getText(), S->getLine())); >> 2776 { FLAGS "=" flagsField ( "\|" flagsField )* "," } 2777 vfrStatementExpression[0] 2778 E:EndIf << CRT_END_OP (E); >> 2779 ";" 2780 ; 2781 2782// 2783// Compatible for framework vfr file 2784// 2785vfrStatementgrayoutIfSuppressIf: 2786 << CIfrSuppressIf SIObj; >> 2787 L:SuppressIf << SIObj.SetLineNo(L->getLine()); >> 2788 { FLAGS "=" flagsField ( "\|" flagsField )* "," } 2789 vfrStatementExpression[0] 2790 ";" 2791 ; 2792 2793vfrStatementsuppressIfGrayOutIf: 2794 << CIfrGrayOutIf GOIObj; >> 2795 L:GrayOutIf << GOIObj.SetLineNo(L->getLine()); >> 2796 { FLAGS "=" flagsField ( "\|" flagsField )* "," } 2797 vfrStatementExpression[0] 2798 ";" 2799 ; 2800 2801vfrStatementSuppressIfStatNew : 2802 << CIfrSuppressIf SIObj;>> 2803 L:SuppressIf << SIObj.SetLineNo(L->getLine()); >> 2804 { FLAGS "=" flagsField ( "\|" flagsField )* "," } 2805 vfrStatementExpression[0] 2806 ";" 2807 ( vfrStatementStatList )* 2808 E: EndIf ";" << CRT_END_OP (E); >> 2809 ; 2810 2811vfrStatementGrayOutIfStatNew : 2812 << CIfrGrayOutIf GOIObj;>> 2813 L:GrayOutIf << GOIObj.SetLineNo(L->getLine()); >> 2814 { FLAGS "=" flagsField ( "\|" flagsField )* "," } 2815 vfrStatementExpression[0] 2816 ";" 2817 ( vfrStatementStatList )* 2818 E: EndIf ";" << CRT_END_OP (E); >> 2819 ; 2820 2821vfrStatementSuppressIfStatOld : 2822 << 2823 CIfrSuppressIf SIObj; 2824 BOOLEAN GrayOutExist = FALSE; 2825 >> 2826 L:SuppressIf << SIObj.SetLineNo(L->getLine()); >> 2827 { FLAGS "=" flagsField ( "\|" flagsField )* "," } 2828 vfrStatementExpression[0] 2829 ";" 2830 { 2831 vfrStatementsuppressIfGrayOutIf 2832 << GrayOutExist = TRUE; >> 2833 } 2834 ( vfrStatementStatListOld )* 2835 E: EndIf ";" << if (GrayOutExist) CRT_END_OP (E); CRT_END_OP (E);>> 2836 ; 2837 2838vfrStatementGrayOutIfStatOld : 2839 << 2840 CIfrGrayOutIf GOIObj; 2841 BOOLEAN SuppressExist = FALSE; 2842 >> 2843 L:GrayOutIf << GOIObj.SetLineNo(L->getLine()); >> 2844 { FLAGS "=" flagsField ( "\|" flagsField )* "," } 2845 vfrStatementExpression[0] 2846 ";" 2847 { 2848 vfrStatementgrayoutIfSuppressIf 2849 << SuppressExist = TRUE; >> 2850 } 2851 ( vfrStatementStatListOld )* 2852 E: EndIf ";" << if (SuppressExist) CRT_END_OP (E); CRT_END_OP (E); >> 2853 ; 2854 2855vfrImageTag : 2856 << CIfrImage IObj; >> 2857 L:Image "=" "IMAGE_TOKEN" "\(" S1:Number "\)" << IObj.SetImageId (_STOSID(S1->getText(), S1->getLine())); IObj.SetLineNo(L->getLine()); >> 2858 ; 2859 2860vfrLockedTag : 2861 << CIfrLocked LObj; >> 2862 L:Locked << LObj.SetLineNo(L->getLine()); >> 2863 ; 2864 2865vfrModalTag : 2866 << CIfrModal MObj; >> 2867 L:Modal << MObj.SetLineNo(L->getLine()); >> 2868 ; 2869 2870vfrStatementStatTag : 2871 vfrImageTag | 2872 vfrLockedTag 2873 ; 2874 2875vfrStatementStatTagList : 2876 vfrStatementStatTag ( "," vfrStatementStatTag )* 2877 ; 2878 2879vfrStatementImage : 2880 vfrImageTag 2881 ";" 2882 ; 2883 2884vfrStatementModal : 2885 vfrModalTag 2886 ";" 2887 ; 2888 2889vfrStatementLocked : 2890 vfrLockedTag 2891 ";" 2892 ; 2893 2894vfrStatementInconsistentIf : 2895 << CIfrInconsistentIf IIObj; >> 2896 L:InconsistentIf << IIObj.SetLineNo(L->getLine()); >> 2897 Prompt "=" "STRING_TOKEN" "\(" S:Number "\)" "," << IIObj.SetError (_STOSID(S->getText(), S->getLine())); >> 2898 { FLAGS "=" flagsField ( "\|" flagsField )* "," } 2899 vfrStatementExpression[0] 2900 E:EndIf << CRT_END_OP (E); >> 2901 ; 2902 2903vfrStatementNoSubmitIf : 2904 << CIfrNoSubmitIf NSIObj; >> 2905 L:NoSubmitIf << NSIObj.SetLineNo(L->getLine()); >> 2906 Prompt "=" "STRING_TOKEN" "\(" S:Number "\)" "," << NSIObj.SetError (_STOSID(S->getText(), S->getLine())); >> 2907 { FLAGS "=" flagsField ( "\|" flagsField )* "," } 2908 vfrStatementExpression[0] 2909 E:EndIf << CRT_END_OP (E); >> 2910 ; 2911 2912vfrStatementWarningIf : 2913 << CIfrWarningIf WIObj; >> 2914 L:WarningIf << WIObj.SetLineNo(L->getLine()); >> 2915 Prompt "=" "STRING_TOKEN" "\(" S:Number "\)" "," << WIObj.SetWarning (_STOSID(S->getText(), S->getLine())); >> 2916 {Timeout "=" T:Number "," << WIObj.SetTimeOut (_STOU8(T->getText(), T->getLine())); >>} 2917 vfrStatementExpression[0] 2918 E:EndIf << CRT_END_OP (E); >> 2919 ; 2920 2921vfrStatementDisableIfQuest : 2922 << 2923 CIfrDisableIf DIObj; 2924 >> 2925 L:DisableIf << DIObj.SetLineNo(L->getLine()); >> 2926 vfrStatementExpression[0] ";" 2927 vfrStatementQuestionOptionList 2928 E:EndIf << CRT_END_OP (E); >> 2929 ; 2930 2931vfrStatementRefresh : 2932 << CIfrRefresh RObj; >> 2933 L:Refresh << RObj.SetLineNo(L->getLine()); >> 2934 Interval "=" I:Number << RObj.SetRefreshInterval (_STOU8(I->getText(), I->getLine())); >> 2935 ; 2936 2937vfrStatementRefreshEvent : 2938 << 2939 CIfrRefreshId RiObj; 2940 EFI_GUID Guid; 2941 >> 2942 L:RefreshGuid << RiObj.SetLineNo(L->getLine()); >> 2943 "=" guidDefinition[Guid] "," << RiObj.SetRefreshEventGroutId (&Guid); >> 2944 ; 2945 2946vfrStatementVarstoreDevice : 2947 << CIfrVarStoreDevice VDObj; >> 2948 L:VarstoreDevice << VDObj.SetLineNo(L->getLine()); >> 2949 "=" "STRING_TOKEN" "\(" S:Number "\)" "," << VDObj.SetDevicePath (_STOSID(S->getText(), S->getLine())); >> 2950 ; 2951 2952vfrStatementSuppressIfQuest : 2953 << CIfrSuppressIf SIObj; >> 2954 L:SuppressIf << SIObj.SetLineNo(L->getLine()); >> 2955 { FLAGS "=" flagsField ( "\|" flagsField )* "," } 2956 vfrStatementExpression[0] ";" 2957 vfrStatementQuestionOptionList 2958 E:EndIf << CRT_END_OP (E); >> 2959 ; 2960 2961vfrStatementGrayOutIfQuest : 2962 << CIfrGrayOutIf GOIObj; >> 2963 L:GrayOutIf << GOIObj.SetLineNo(L->getLine()); >> 2964 { FLAGS "=" flagsField ( "\|" flagsField )* "," } 2965 vfrStatementExpression[0] ";" 2966 vfrStatementQuestionOptionList 2967 E:EndIf << CRT_END_OP (E); >> 2968 ; 2969 2970vfrStatementOptions : 2971 vfrStatementOneOfOption 2972 ; 2973 2974vfrStatementOneOfOption : 2975 << 2976 EFI_IFR_TYPE_VALUE Val = gZeroEfiIfrTypeValue; 2977 CHAR8 *VarStoreName = NULL; 2978 UINT32 Size = 0; 2979 BOOLEAN TypeError = FALSE; 2980 EFI_VFR_RETURN_CODE ReturnCode = VFR_RETURN_SUCCESS; 2981 EFI_GUID *VarStoreGuid = NULL; 2982 2983 if (_GET_CURRQEST_DATATYPE() == EFI_IFR_TYPE_OTHER) { 2984 TypeError = TRUE; 2985 Size = sizeof (EFI_IFR_TYPE_VALUE); 2986 } else { 2987 ReturnCode = gCVfrVarDataTypeDB.GetDataTypeSize (_GET_CURRQEST_DATATYPE(), &Size); 2988 } 2989 2990 Size += OFFSET_OF (EFI_IFR_ONE_OF_OPTION, Value); 2991 CIfrOneOfOption OOOObj ((UINT8)Size); 2992 >> 2993 L:Option << 2994 OOOObj.SetLineNo(L->getLine()); 2995 if (TypeError) { 2996 _PCATCH (VFR_RETURN_FATAL_ERROR, L->getLine(), "Get data type error."); 2997 } 2998 if (ReturnCode != VFR_RETURN_SUCCESS) { 2999 _PCATCH (ReturnCode, L->getLine()); 3000 } 3001 >> 3002 Text "=" "STRING_TOKEN" "\(" S:Number "\)" "," << OOOObj.SetOption (_STOSID(S->getText(), S->getLine())); >> 3003 Value "=" vfrConstantValueField[_GET_CURRQEST_DATATYPE()] >[Val] "," 3004 << 3005 if (gCurrentMinMaxData != NULL) { 3006 //set min/max value for oneof opcode 3007 UINT64 Step = gCurrentMinMaxData->GetStepData(_GET_CURRQEST_DATATYPE()); 3008 switch (_GET_CURRQEST_DATATYPE()) { 3009 case EFI_IFR_TYPE_NUM_SIZE_64: 3010 gCurrentMinMaxData->SetMinMaxStepData(Val.u64, Val.u64, Step); 3011 break; 3012 case EFI_IFR_TYPE_NUM_SIZE_32: 3013 gCurrentMinMaxData->SetMinMaxStepData(Val.u32, Val.u32, (UINT32) Step); 3014 break; 3015 case EFI_IFR_TYPE_NUM_SIZE_16: 3016 gCurrentMinMaxData->SetMinMaxStepData(Val.u16, Val.u16, (UINT16) Step); 3017 break; 3018 case EFI_IFR_TYPE_NUM_SIZE_8: 3019 gCurrentMinMaxData->SetMinMaxStepData(Val.u8, Val.u8, (UINT8) Step); 3020 break; 3021 default: 3022 break; 3023 } 3024 } 3025 OOOObj.SetType (_GET_CURRQEST_DATATYPE()); 3026 OOOObj.SetValue (Val); 3027 >> 3028 F:FLAGS "=" vfrOneOfOptionFlags[OOOObj, F->getLine()] 3029 << 3030 if (_GET_CURRQEST_VARTINFO().mVarStoreId != EFI_VARSTORE_ID_INVALID) { 3031 _PCATCH(mCVfrDataStorage.GetVarStoreName (_GET_CURRQEST_VARTINFO().mVarStoreId, &VarStoreName), L->getLine()); 3032 VarStoreGuid = mCVfrDataStorage.GetVarStoreGuid(_GET_CURRQEST_VARTINFO().mVarStoreId); 3033 if (OOOObj.GetFlags () & 0x10) { 3034 CheckDuplicateDefaultValue (EFI_HII_DEFAULT_CLASS_STANDARD, F); 3035 _PCATCH(mCVfrDefaultStore.BufferVarStoreAltConfigAdd ( 3036 EFI_HII_DEFAULT_CLASS_STANDARD, 3037 _GET_CURRQEST_VARTINFO(), 3038 VarStoreName, 3039 VarStoreGuid, 3040 _GET_CURRQEST_DATATYPE (), 3041 Val 3042 ), L->getLine()); 3043 } 3044 if (OOOObj.GetFlags () & 0x20) { 3045 CheckDuplicateDefaultValue (EFI_HII_DEFAULT_CLASS_MANUFACTURING, F); 3046 _PCATCH(mCVfrDefaultStore.BufferVarStoreAltConfigAdd ( 3047 EFI_HII_DEFAULT_CLASS_MANUFACTURING, 3048 _GET_CURRQEST_VARTINFO(), 3049 VarStoreName, 3050 VarStoreGuid, 3051 _GET_CURRQEST_DATATYPE (), 3052 Val 3053 ), L->getLine()); 3054 } 3055 } 3056 >> 3057 { 3058 "," Key "=" KN:Number << 3059 if (!mCompatibleMode) { 3060 _PCATCH (VFR_RETURN_UNSUPPORTED, KN); 3061 } 3062 // 3063 // Guid Option Key 3064 // 3065 CIfrOptionKey IfrOptionKey ( 3066 gCurrentQuestion->QUESTION_ID(), 3067 Val, 3068 _STOQID(KN->getText(), KN->getLine()) 3069 ); 3070 SET_LINE_INFO (IfrOptionKey, KN); 3071 >> 3072 } 3073 ( 3074 T:"," vfrImageTag << OOOObj.SetScope (1); CRT_END_OP (T); >> 3075 )* 3076 ";" 3077 ; 3078 3079vfrOneOfOptionFlags [CIfrOneOfOption & OOOObj, UINT32 LineNum] : 3080 << 3081 UINT8 LFlags = _GET_CURRQEST_DATATYPE(); 3082 UINT8 HFlags = 0; 3083 >> 3084 oneofoptionFlagsField[HFlags, LFlags] ( "\|" oneofoptionFlagsField[HFlags, LFlags] )* 3085 << _PCATCH(gCurrentQuestion->SetFlags(HFlags), LineNum); >> 3086 << _PCATCH(OOOObj.SetFlags(LFlags), LineNum); >> 3087 ; 3088 3089oneofoptionFlagsField [UINT8 & HFlags, UINT8 & LFlags] : 3090 N:Number << $LFlags |= _STOU8(N->getText(), N->getLine()); >> 3091 | "OPTION_DEFAULT" << $LFlags |= 0x10; >> 3092 | "OPTION_DEFAULT_MFG" << $LFlags |= 0x20; >> 3093 | InteractiveFlag << $HFlags |= 0x04; >> 3094 | ResetRequiredFlag << $HFlags |= 0x10; >> 3095 | ManufacturingFlag << $LFlags |= 0x20; >> 3096 | DefaultFlag << $LFlags |= 0x10; >> 3097 | A:NVAccessFlag << 3098 if (mCompatibleMode) { 3099 $HFlags |= 0x08; 3100 } else { 3101 gCVfrErrorHandle.HandleWarning ( 3102 VFR_WARNING_OBSOLETED_FRAMEWORK_OPCODE, 3103 A->getLine(), 3104 A->getText() 3105 ); 3106 } 3107 >> 3108 | L:LateCheckFlag << 3109 if (mCompatibleMode) { 3110 $HFlags |= 0x20; 3111 } else { 3112 gCVfrErrorHandle.HandleWarning ( 3113 VFR_WARNING_OBSOLETED_FRAMEWORK_OPCODE, 3114 L->getLine(), 3115 L->getText() 3116 ); 3117 } 3118 >> 3119 ; 3120 3121vfrStatementLabel : 3122 L:Label 3123 N:Number << 3124 if (mCompatibleMode) { 3125 // 3126 // Add end Label for Framework Vfr 3127 // 3128 CIfrLabel LObj1; 3129 LObj1.SetLineNo(L->getLine()); 3130 LObj1.SetNumber (0xffff); //add end label for UEFI, label number hardcode 0xffff 3131 } 3132 3133 { 3134 CIfrLabel LObj2; 3135 LObj2.SetLineNo(L->getLine()); 3136 LObj2.SetNumber (_STOU16(N->getText(), N->getLine())); 3137 } 3138 >> 3139 ";" 3140 ; 3141 3142vfrStatementBanner : 3143 << CIfrBanner BObj; >> 3144 B:Banner { "," } << BObj.SetLineNo(B->getLine()); >> 3145 Title "=" "STRING_TOKEN" "\(" S:Number "\)" "," << BObj.SetTitle (_STOSID(S->getText(), S->getLine())); >> 3146 ( 3147 ( 3148 Line L:Number "," << BObj.SetLine (_STOU16(L->getText(), L->getLine())); >> 3149 Align 3150 ( 3151 Left << BObj.SetAlign (0); >> 3152 | Center << BObj.SetAlign (1); >> 3153 | Right << BObj.SetAlign (2); >> 3154 ) ";" 3155 ) 3156 | 3157 ( 3158 Timeout "=" T:Number ";" << {CIfrTimeout TObj(_STOU16(T->getText(), T->getLine()));} >> 3159 ) 3160 ) 3161 ; 3162 3163//****************************************************************************** 3164// 3165// keep some syntax for compatibility but not generate any IFR object 3166// 3167vfrStatementInvalidHidden : 3168 L:Hidden << 3169 if (!mCompatibleMode) { 3170 _PCATCH (VFR_RETURN_UNSUPPORTED, L); 3171 } 3172 >> 3173 Value "=" Number "," 3174 Key "=" Number ";" 3175 ; 3176 3177vfrStatementInvalidInconsistentIf : 3178 InconsistentIf 3179 Prompt "=" "STRING_TOKEN" "\(" S:Number "\)" "," 3180 { FLAGS "=" flagsField ( "\|" flagsField )* "," } 3181 vfrStatementExpression[0] 3182 EndIf 3183 ";" 3184 ; 3185 3186vfrStatementInvalidInventory : 3187 L:Inventory << 3188 if (!mCompatibleMode) { 3189 _PCATCH (VFR_RETURN_UNSUPPORTED, L); 3190 } 3191 >> 3192 Help "=" "STRING_TOKEN" "\(" Number "\)" "," 3193 Text "=" "STRING_TOKEN" "\(" Number "\)" "," 3194 { 3195 Text "=" "STRING_TOKEN" "\(" Number "\)" 3196 } 3197 ";" 3198 ; 3199 3200vfrStatementInvalidSaveRestoreDefaults : 3201 ( 3202 L:Save << 3203 if (!mCompatibleMode) { 3204 _PCATCH (VFR_RETURN_UNSUPPORTED, L); 3205 } 3206 >> 3207 | 3208 K:Restore << 3209 if (!mCompatibleMode) { 3210 _PCATCH (VFR_RETURN_UNSUPPORTED, K); 3211 } 3212 >> 3213 ) 3214 Defaults "," 3215 FormId "=" Number "," 3216 Prompt "=" "STRING_TOKEN" "\(" Number "\)" "," 3217 Help "=" "STRING_TOKEN" "\(" Number "\)" 3218 { "," FLAGS "=" flagsField ( "\|" flagsField )* } 3219 { "," Key "=" Number } 3220 ";" 3221 ; 3222 3223//****************************************************************************** 3224// 3225// The syntax of expression 3226// 3227#token Dup("dup") "dup" 3228#token VarEqVal("vareqval") "vareqval" 3229#token Var("var") "var" 3230#token IdEqVal("ideqval") "ideqval" 3231#token IdEqId("ideqid") "ideqid" 3232#token IdEqValList("ideqvallist") "ideqvallist" 3233#token QuestionRef("questionref") "questionref" 3234#token RuleRef("ruleref") "ruleref" 3235#token StringRef("stringref") "stringref" 3236#token PushThis("pushthis") "pushthis" 3237#token Security("security") "security" 3238#token Get("get") "get" 3239#token True("TRUE") "TRUE" 3240#token False("FALSE") "FALSE" 3241#token One("ONE") "ONE" 3242#token Ones("ONES") "ONES" 3243#token Zero("ZERO") "ZERO" 3244#token Undefined("UNDEFINED") "UNDEFINED" 3245#token Version("VERSION") "VERSION" 3246#token Length("length") "length" 3247#token AND("AND") "AND" 3248#token OR("OR") "OR" 3249#token NOT("NOT") "NOT" 3250#token Set("set") "set" 3251#token BitWiseNot("~") "\~" 3252#token BoolVal("boolval") "boolval" 3253#token StringVal("stringval") "stringval" 3254#token UnIntVal("unintval") "unintval" 3255#token ToUpper("toupper") "toupper" 3256#token ToLower("tolower") "tolower" 3257#token Match("match") "match" 3258#token Catenate("catenate") "catenate" 3259#token QuestionRefVal("questionrefval") "questionrefval" 3260#token StringRefVal("stringrefval") "stringrefval" 3261#token Map("map") "map" 3262#token RefreshGuid("refreshguid") "refreshguid" 3263 3264// 3265// Root expression extension function called by other function. 3266// 3267vfrStatementExpression [UINT32 RootLevel, UINT32 ExpOpCount = 0] : 3268 << 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 ();} >> 3269 andTerm[$RootLevel, $ExpOpCount] 3270 ( 3271 L:OR andTerm[$RootLevel, $ExpOpCount] << $ExpOpCount++; CIfrOr OObj(L->getLine()); >> 3272 )* 3273 << 3274 // 3275 // Extend OpCode Scope only for the root expression. 3276 // 3277 if ($ExpOpCount > 1 && $RootLevel == 0) { 3278 if (_SET_SAVED_OPHDR_SCOPE()) { 3279 CIfrEnd EObj; 3280 if (mCIfrOpHdrLineNo[mCIfrOpHdrIndex] != 0) { 3281 EObj.SetLineNo (mCIfrOpHdrLineNo[mCIfrOpHdrIndex]); 3282 } 3283 } 3284 } 3285 3286 if ($RootLevel == 0) { 3287 mCIfrOpHdrIndex --; 3288 } 3289 >> 3290 ; 3291 3292// 3293// Add new sub function for the sub expression extension to remember the ExpOpCount 3294// This funciton is only called by sub expression. 3295// 3296vfrStatementExpressionSub [UINT32 RootLevel, UINT32 & ExpOpCount] : 3297 andTerm[$RootLevel, $ExpOpCount] 3298 ( 3299 L:OR andTerm[$RootLevel, $ExpOpCount] << $ExpOpCount++; CIfrOr OObj(L->getLine()); >> 3300 )* 3301 ; 3302 3303andTerm[UINT32 & RootLevel, UINT32 & ExpOpCount] : 3304 bitwiseorTerm[$RootLevel, $ExpOpCount] 3305 ( 3306 L:AND bitwiseorTerm [$RootLevel, $ExpOpCount] << $ExpOpCount++; CIfrAnd AObj(L->getLine()); >> 3307 )* 3308 ; 3309 3310bitwiseorTerm [UINT32 & RootLevel, UINT32 & ExpOpCount]: 3311 bitwiseandTerm[$RootLevel, $ExpOpCount] 3312 ( 3313 L:"\|" bitwiseandTerm[$RootLevel, $ExpOpCount] << $ExpOpCount++; CIfrBitWiseOr BWOObj(L->getLine()); >> 3314 )* 3315 ; 3316 3317bitwiseandTerm [UINT32 & RootLevel, UINT32 & ExpOpCount]: 3318 equalTerm[$RootLevel, $ExpOpCount] 3319 ( 3320 L:"&" equalTerm[$RootLevel, $ExpOpCount] << $ExpOpCount++; CIfrBitWiseAnd BWAObj(L->getLine()); >> 3321 )* 3322 ; 3323 3324equalTerm [UINT32 & RootLevel, UINT32 & ExpOpCount]: 3325 compareTerm[$RootLevel, $ExpOpCount] 3326 ( 3327 ( 3328 L1:"==" compareTerm[$RootLevel, $ExpOpCount] << $ExpOpCount++; CIfrEqual EObj(L1->getLine()); >> 3329 ) 3330 | 3331 ( 3332 L2:"!=" compareTerm[$RootLevel, $ExpOpCount] << $ExpOpCount++; CIfrNotEqual NEObj(L2->getLine()); >> 3333 ) 3334 )* 3335 ; 3336 3337compareTerm [UINT32 & RootLevel, UINT32 & ExpOpCount]: 3338 shiftTerm[$RootLevel, $ExpOpCount] 3339 ( 3340 ( 3341 L1:"<" shiftTerm[$RootLevel, $ExpOpCount] << $ExpOpCount++; CIfrLessThan LTObj(L1->getLine()); >> 3342 ) 3343 | 3344 ( 3345 L2:"<=" shiftTerm[$RootLevel, $ExpOpCount] << $ExpOpCount++; CIfrLessEqual LEObj(L2->getLine()); >> 3346 ) 3347 | 3348 ( 3349 L3:">" shiftTerm[$RootLevel, $ExpOpCount] << $ExpOpCount++; CIfrGreaterThan GTObj(L3->getLine()); >> 3350 ) 3351 | 3352 ( 3353 L4:">=" shiftTerm[$RootLevel, $ExpOpCount] << $ExpOpCount++; CIfrGreaterEqual GEObj(L4->getLine()); >> 3354 ) 3355 )* 3356 ; 3357 3358shiftTerm [UINT32 & RootLevel, UINT32 & ExpOpCount]: 3359 addMinusTerm[$RootLevel, $ExpOpCount] 3360 ( 3361 ( 3362 L1:"\<<" addMinusTerm[$RootLevel, $ExpOpCount] << $ExpOpCount++; CIfrShiftLeft SLObj(L1->getLine()); >> 3363 ) 3364 | 3365 ( 3366 L2:"\>>" addMinusTerm[$RootLevel, $ExpOpCount] << $ExpOpCount++; CIfrShiftRight SRObj(L2->getLine()); >> 3367 ) 3368 )* 3369 ; 3370 3371addMinusTerm [UINT32 & RootLevel, UINT32 & ExpOpCount]: 3372 multdivmodTerm[$RootLevel, $ExpOpCount] 3373 ( 3374 ( 3375 L1:"\+" multdivmodTerm[$RootLevel, $ExpOpCount] << $ExpOpCount++; CIfrAdd AObj(L1->getLine()); >> 3376 ) 3377 | 3378 ( 3379 L2:"\-" multdivmodTerm[$RootLevel, $ExpOpCount] << $ExpOpCount++; CIfrSubtract SObj(L2->getLine()); >> 3380 ) 3381 )* 3382 ; 3383 3384multdivmodTerm [UINT32 & RootLevel, UINT32 & ExpOpCount]: 3385 castTerm[$RootLevel, $ExpOpCount] 3386 ( 3387 ( 3388 L1:"\*" castTerm[$RootLevel, $ExpOpCount] << $ExpOpCount++; CIfrMultiply MObj(L1->getLine()); >> 3389 ) 3390 | 3391 ( 3392 L2:"/" castTerm[$RootLevel, $ExpOpCount] << $ExpOpCount++; CIfrDivide DObj(L2->getLine()); >> 3393 ) 3394 | 3395 ( 3396 L3:"%" castTerm[$RootLevel, $ExpOpCount] << $ExpOpCount++; CIfrModulo MObj(L3->getLine()); >> 3397 ) 3398 )* 3399 ; 3400 3401castTerm [UINT32 & RootLevel, UINT32 & ExpOpCount]: 3402 << UINT8 CastType = 0xFF; >> 3403 ( 3404 L:"\(" 3405 ( 3406 Boolean << CastType = 0; >> 3407 | Uint64 << CastType = 1; >> 3408 | Uint32 << CastType = 1; >> 3409 | Uint16 << CastType = 1; >> 3410 | Uint8 << CastType = 1; >> 3411 ) 3412 "\)" 3413 )* 3414 atomTerm[$RootLevel, $ExpOpCount] 3415 << 3416 switch (CastType) { 3417 case 0: { CIfrToBoolean TBObj(L->getLine()); $ExpOpCount++; } break; 3418 case 1: { CIfrToUint TUObj(L->getLine()); $ExpOpCount++; } break; 3419 } 3420 >> 3421 ; 3422 3423atomTerm [UINT32 & RootLevel, UINT32 & ExpOpCount]: 3424 vfrExpressionCatenate[$RootLevel, $ExpOpCount] 3425 | vfrExpressionMatch[$RootLevel, $ExpOpCount] 3426 | vfrExpressionParen[$RootLevel, $ExpOpCount] 3427 | vfrExpressionBuildInFunction[$RootLevel, $ExpOpCount] 3428 | vfrExpressionConstant[$RootLevel, $ExpOpCount] 3429 | vfrExpressionUnaryOp[$RootLevel, $ExpOpCount] 3430 | vfrExpressionTernaryOp[$RootLevel, $ExpOpCount] 3431 | vfrExpressionMap[$RootLevel, $ExpOpCount] 3432 | ( 3433 L:NOT 3434 atomTerm[$RootLevel, $ExpOpCount] << { CIfrNot NObj(L->getLine()); $ExpOpCount++; } >> 3435 ) 3436 ; 3437 3438vfrExpressionCatenate [UINT32 & RootLevel, UINT32 & ExpOpCount]: 3439 L:Catenate 3440 "\(" 3441 vfrStatementExpressionSub[$RootLevel + 1, $ExpOpCount] 3442 "," 3443 vfrStatementExpressionSub[$RootLevel + 1, $ExpOpCount] 3444 "\)" << { CIfrCatenate CObj(L->getLine()); $ExpOpCount++; } >> 3445 ; 3446 3447vfrExpressionMatch [UINT32 & RootLevel, UINT32 & ExpOpCount]: 3448 L:Match 3449 "\(" 3450 vfrStatementExpressionSub[$RootLevel + 1, $ExpOpCount] 3451 "," 3452 vfrStatementExpressionSub[$RootLevel + 1, $ExpOpCount] 3453 "\)" << { CIfrMatch MObj(L->getLine()); $ExpOpCount++; } >> 3454 ; 3455 3456vfrExpressionParen [UINT32 & RootLevel, UINT32 & ExpOpCount]: 3457 "\(" 3458 vfrStatementExpressionSub[$RootLevel + 1, $ExpOpCount] 3459 "\)" 3460 ; 3461 3462vfrExpressionBuildInFunction [UINT32 & RootLevel, UINT32 & ExpOpCount] : 3463 dupExp[$RootLevel, $ExpOpCount] 3464 | vareqvalExp[$RootLevel, $ExpOpCount] //Compatible for Framework vareqval 3465 | ideqvalExp[$RootLevel, $ExpOpCount] 3466 | ideqidExp[$RootLevel, $ExpOpCount] 3467 | ideqvallistExp[$RootLevel, $ExpOpCount] 3468 | questionref1Exp[$RootLevel, $ExpOpCount] 3469 | rulerefExp[$RootLevel, $ExpOpCount] 3470 | stringref1Exp[$RootLevel, $ExpOpCount] 3471 | pushthisExp[$RootLevel, $ExpOpCount] 3472 | securityExp[$RootLevel, $ExpOpCount] 3473 | getExp[$RootLevel, $ExpOpCount] 3474 ; 3475 3476dupExp [UINT32 & RootLevel, UINT32 & ExpOpCount] : 3477 L:Dup << { CIfrDup DObj(L->getLine()); _SAVE_OPHDR_COND(DObj, ($ExpOpCount == 0), L->getLine()); $ExpOpCount++; } >> 3478 ; 3479 3480vareqvalExp [UINT32 & RootLevel, UINT32 & ExpOpCount] : 3481 << 3482 EFI_QUESTION_ID QId; 3483 UINT32 Mask; 3484 UINT16 ConstVal; 3485 CHAR8 *VarIdStr; 3486 UINT32 LineNo; 3487 EFI_VFR_RETURN_CODE VfrReturnCode = VFR_RETURN_SUCCESS; 3488 EFI_VARSTORE_ID VarStoreId = EFI_VARSTORE_ID_INVALID; 3489 >> 3490 L:VarEqVal << 3491 if (!mCompatibleMode) { 3492 _PCATCH (VFR_RETURN_UNSUPPORTED, L); 3493 } 3494 >> 3495 VK:Var 3496 OpenParen 3497 VN:Number << 3498 VarIdStr = NULL; _STRCAT(&VarIdStr, VK->getText()); _STRCAT(&VarIdStr, VN->getText()); 3499 VfrReturnCode = mCVfrDataStorage.GetVarStoreId (VarIdStr, &VarStoreId); 3500 if (VfrReturnCode == VFR_RETURN_UNDEFINED) { 3501 _PCATCH (mCVfrDataStorage.DeclareEfiVarStore ( 3502 VarIdStr, 3503 &mFormsetGuid, 3504 _STOSID(VN->getText(), VN->getLine()), 3505 0x2, //default type is UINT16 3506 FALSE 3507 ), VN); 3508 } else { 3509 _PCATCH (VfrReturnCode, VN); 3510 } 3511 mCVfrQuestionDB.GetQuestionId (NULL, VarIdStr, QId, Mask); 3512 LineNo = GET_LINENO(VN); 3513 >> 3514 CloseParen 3515 ( 3516 ( 3517 "==" 3518 V1:Number << ConstVal = _STOU16(V1->getText(), V1->getLine()); >> 3519 << 3520 if (Mask == 0) { 3521 CIfrEqIdVal EIVObj (L->getLine()); 3522 _SAVE_OPHDR_COND (EIVObj, ($ExpOpCount == 0), L->getLine()); 3523 EIVObj.SetQuestionId (QId, VarIdStr, LineNo); 3524 EIVObj.SetValue (ConstVal); 3525 $ExpOpCount++; 3526 } else { 3527 IdEqValDoSpecial ($ExpOpCount, L->getLine(), QId, VarIdStr, Mask, ConstVal, EQUAL); 3528 } 3529 >> 3530 ) 3531 | 3532 ( 3533 "<=" 3534 V2:Number << ConstVal = _STOU16(V2->getText(), V2->getLine()); >> 3535 << IdEqValDoSpecial ($ExpOpCount, L->getLine(), QId, VarIdStr, Mask, ConstVal, LESS_EQUAL); >> 3536 ) 3537 | 3538 ( 3539 "<" 3540 V3:Number << ConstVal = _STOU16(V3->getText(), V3->getLine()); >> 3541 << IdEqValDoSpecial ($ExpOpCount, L->getLine(), QId, VarIdStr, Mask, ConstVal, LESS_THAN); >> 3542 ) 3543 | 3544 ( 3545 ">=" 3546 V4:Number << ConstVal = _STOU16(V4->getText(), V4->getLine()); >> 3547 << IdEqValDoSpecial ($ExpOpCount, L->getLine(), QId, VarIdStr, Mask, ConstVal, GREATER_EQUAL); >> 3548 ) 3549 | 3550 ( 3551 ">" 3552 V5:Number << ConstVal = _STOU16(V5->getText(), V5->getLine()); >> 3553 << IdEqValDoSpecial ($ExpOpCount, L->getLine(), QId, VarIdStr, Mask, ConstVal, GREATER_THAN); >> 3554 ) 3555 ) 3556 ; 3557 3558ideqvalExp [UINT32 & RootLevel, UINT32 & ExpOpCount] : 3559 << 3560 EFI_QUESTION_ID QId; 3561 UINT32 Mask; 3562 UINT16 ConstVal; 3563 CHAR8 *VarIdStr; 3564 UINT32 LineNo; 3565 >> 3566 L:IdEqVal 3567 vfrQuestionDataFieldName[QId, Mask, VarIdStr, LineNo] 3568 ( 3569 ( 3570 "==" 3571 V1:Number << ConstVal = _STOU16(V1->getText(), V1->getLine()); >> 3572 << 3573 if (Mask == 0) { 3574 CIfrEqIdVal EIVObj (L->getLine()); 3575 _SAVE_OPHDR_COND (EIVObj, ($ExpOpCount == 0), L->getLine()); 3576 EIVObj.SetQuestionId (QId, VarIdStr, LineNo); 3577 EIVObj.SetValue (ConstVal); 3578 $ExpOpCount++; 3579 } else { 3580 IdEqValDoSpecial ($ExpOpCount, L->getLine(), QId, VarIdStr, Mask, ConstVal, EQUAL); 3581 } 3582 >> 3583 ) 3584 | 3585 ( 3586 "<=" 3587 V2:Number << ConstVal = _STOU16(V2->getText(), V2->getLine()); >> 3588 << IdEqValDoSpecial ($ExpOpCount, L->getLine(), QId, VarIdStr, Mask, ConstVal, LESS_EQUAL); >> 3589 ) 3590 | 3591 ( 3592 "<" 3593 V3:Number << ConstVal = _STOU16(V3->getText(), V3->getLine()); >> 3594 << IdEqValDoSpecial ($ExpOpCount, L->getLine(), QId, VarIdStr, Mask, ConstVal, LESS_THAN); >> 3595 ) 3596 | 3597 ( 3598 ">=" 3599 V4:Number << ConstVal = _STOU16(V4->getText(), V4->getLine()); >> 3600 << IdEqValDoSpecial ($ExpOpCount, L->getLine(), QId, VarIdStr, Mask, ConstVal, GREATER_EQUAL); >> 3601 ) 3602 | 3603 ( 3604 ">" 3605 V5:Number << ConstVal = _STOU16(V5->getText(), V5->getLine()); >> 3606 << IdEqValDoSpecial ($ExpOpCount, L->getLine(), QId, VarIdStr, Mask, ConstVal, GREATER_THAN); >> 3607 ) 3608 ) 3609 ; 3610 3611ideqidExp[UINT32 & RootLevel, UINT32 & ExpOpCount] : 3612 << 3613 EFI_QUESTION_ID QId[2]; 3614 UINT32 Mask[2]; 3615 CHAR8 *VarIdStr[2]; 3616 UINT32 LineNo[2]; 3617 >> 3618 L:IdEqId 3619 vfrQuestionDataFieldName[QId[0], Mask[0], VarIdStr[0], LineNo[0]] 3620 ( 3621 ( 3622 "==" 3623 vfrQuestionDataFieldName[QId[1], Mask[1], VarIdStr[1], LineNo[1]] 3624 << 3625 if (Mask[0] & Mask[1]) { 3626 IdEqIdDoSpecial ($ExpOpCount, L->getLine(), QId[0], VarIdStr[0], Mask[0], QId[1], VarIdStr[1], Mask[1], EQUAL); 3627 } else { 3628 CIfrEqIdId EIIObj(L->getLine()); 3629 _SAVE_OPHDR_COND (EIIObj, ($ExpOpCount == 0), L->getLine()); 3630 EIIObj.SetQuestionId1 (QId[0], VarIdStr[0], LineNo[0]); 3631 EIIObj.SetQuestionId2 (QId[1], VarIdStr[1], LineNo[1]); 3632 $ExpOpCount++; 3633 } 3634 >> 3635 ) 3636 | 3637 ( 3638 "<=" 3639 vfrQuestionDataFieldName[QId[1], Mask[1], VarIdStr[1], LineNo[1]] 3640 << IdEqIdDoSpecial ($ExpOpCount, L->getLine(), QId[0], VarIdStr[0], Mask[0], QId[1], VarIdStr[1], Mask[1], LESS_EQUAL); >> 3641 ) 3642 | 3643 ( 3644 "<" 3645 vfrQuestionDataFieldName[QId[1], Mask[1], VarIdStr[1], LineNo[1]] 3646 << IdEqIdDoSpecial ($ExpOpCount, L->getLine(), QId[0], VarIdStr[0], Mask[0], QId[1], VarIdStr[1], Mask[1], LESS_THAN); >> 3647 ) 3648 | 3649 ( 3650 ">=" 3651 vfrQuestionDataFieldName[QId[1], Mask[1], VarIdStr[1], LineNo[1]] 3652 << IdEqIdDoSpecial ($ExpOpCount, L->getLine(), QId[0], VarIdStr[0], Mask[0], QId[1], VarIdStr[1], Mask[1], GREATER_EQUAL); >> 3653 ) 3654 | 3655 ( 3656 ">" 3657 vfrQuestionDataFieldName[QId[1], Mask[1], VarIdStr[1], LineNo[1]] 3658 << IdEqIdDoSpecial ($ExpOpCount, L->getLine(), QId[0], VarIdStr[0], Mask[0], QId[1], VarIdStr[1], Mask[1], GREATER_THAN); >> 3659 ) 3660 ) 3661 ; 3662 3663ideqvallistExp[UINT32 & RootLevel, UINT32 & ExpOpCount] : 3664 << 3665 UINT16 ListLen = 0; 3666 EFI_QUESTION_ID QId; 3667 UINT32 Mask; 3668 UINT16 ValueList[EFI_IFR_MAX_LENGTH] = {0,}; 3669 CHAR8 *VarIdStr; 3670 UINT32 LineNo; 3671 >> 3672 L:IdEqValList 3673 vfrQuestionDataFieldName[QId, Mask, VarIdStr, LineNo] 3674 "==" 3675 ( 3676 V:Number << ValueList[ListLen] = _STOU16(V->getText(), V->getLine()); ListLen++; >> 3677 )+ 3678 << 3679 if (Mask != 0) { 3680 IdEqListDoSpecial ($ExpOpCount, LineNo, QId, VarIdStr, Mask, ListLen, ValueList); 3681 } else { 3682 UINT16 Index; 3683 CIfrEqIdList EILObj(L->getLine()); 3684 if (QId != EFI_QUESTION_ID_INVALID) { 3685 EILObj.SetQuestionId (QId, VarIdStr, LineNo); 3686 } 3687 EILObj.SetListLength (ListLen); 3688 for (Index = 0; Index < ListLen; Index++) { 3689 EILObj.SetValueList (Index, ValueList[Index]); 3690 } 3691 3692 EILObj.UpdateIfrBuffer(); 3693 _SAVE_OPHDR_COND (EILObj, ($ExpOpCount == 0), L->getLine()); 3694 3695 if (QId == EFI_QUESTION_ID_INVALID) { 3696 EILObj.SetQuestionId (QId, VarIdStr, LineNo); 3697 } 3698 $ExpOpCount++; 3699 } 3700 >> 3701 ; 3702 3703questionref1Exp[UINT32 & RootLevel, UINT32 & ExpOpCount] : 3704 << 3705 EFI_QUESTION_ID QId = EFI_QUESTION_ID_INVALID; 3706 UINT32 BitMask; 3707 CHAR8 *QName = NULL; 3708 UINT32 LineNo = 0; 3709 >> 3710 L:QuestionRef 3711 "\(" 3712 ( 3713 QN:StringIdentifier << 3714 QName = QN->getText(); 3715 LineNo = QN->getLine(); 3716 mCVfrQuestionDB.GetQuestionId (QN->getText(), NULL, QId, BitMask); 3717 >> 3718 | ID:Number << QId = _STOQID(ID->getText(), ID->getLine()); >> 3719 ) 3720 "\)" 3721 << 3722 { CIfrQuestionRef1 QR1Obj(L->getLine()); _SAVE_OPHDR_COND (QR1Obj, ($ExpOpCount == 0), L->getLine()); QR1Obj.SetQuestionId (QId, QName, LineNo); } $ExpOpCount++; >> 3723 ; 3724 3725rulerefExp[UINT32 & RootLevel, UINT32 & ExpOpCount] : 3726 L:RuleRef 3727 "\(" RN:StringIdentifier "\)" << { CIfrRuleRef RRObj(L->getLine()); _SAVE_OPHDR_COND (RRObj, ($ExpOpCount == 0), L->getLine()); RRObj.SetRuleId (mCVfrRulesDB.GetRuleId (RN->getText())); } $ExpOpCount++; >> 3728 ; 3729 3730//****************************************************** 3731// PARSE: 3732// stringref (STR_FORM_SET_TITLE) 3733// 3734stringref1Exp[UINT32 & RootLevel, UINT32 & ExpOpCount] : 3735 << 3736 EFI_STRING_ID RefStringId = EFI_STRING_ID_INVALID; 3737 >> 3738 L:StringRef 3739 "\(" 3740 ( 3741 "STRING_TOKEN" 3742 "\(" 3743 S:Number << RefStringId = _STOSID(S->getText(), S->getLine()); >> 3744 "\)" 3745 | I:Number << RefStringId = _STOSID(I->getText(), I->getLine()); >> 3746 ) 3747 "\)" << { CIfrStringRef1 SR1Obj(L->getLine()); _SAVE_OPHDR_COND (SR1Obj, ($ExpOpCount == 0), L->getLine()); SR1Obj.SetStringId (RefStringId); $ExpOpCount++; } >> 3748 ; 3749 3750pushthisExp[UINT32 & RootLevel, UINT32 & ExpOpCount] : 3751 L:PushThis << { CIfrThis TObj(L->getLine()); _SAVE_OPHDR_COND (TObj, ($ExpOpCount == 0), L->getLine()); $ExpOpCount++; } >> 3752 ; 3753 3754securityExp[UINT32 & RootLevel, UINT32 & ExpOpCount] : 3755 << 3756 EFI_GUID Guid; 3757 >> 3758 L:Security 3759 "\(" guidDefinition[Guid] "\)" << { CIfrSecurity SObj(L->getLine()); _SAVE_OPHDR_COND (SObj, ($ExpOpCount == 0), L->getLine()); SObj.SetPermissions (&Guid); } $ExpOpCount++; >> 3760 ; 3761 3762numericVarStoreType [UINT8 & VarType] : 3763 "NUMERIC_SIZE_1" << $VarType = EFI_IFR_NUMERIC_SIZE_1; >> 3764 | "NUMERIC_SIZE_2" << $VarType = EFI_IFR_NUMERIC_SIZE_2; >> 3765 | "NUMERIC_SIZE_4" << $VarType = EFI_IFR_NUMERIC_SIZE_4; >> 3766 | "NUMERIC_SIZE_8" << $VarType = EFI_IFR_NUMERIC_SIZE_8; >> 3767 ; 3768 3769getExp[UINT32 & RootLevel, UINT32 & ExpOpCount] : 3770 << 3771 EFI_VARSTORE_INFO Info; 3772 CHAR8 *VarIdStr = NULL; 3773 EFI_QUESTION_ID QId = EFI_QUESTION_ID_INVALID; 3774 UINT32 Mask = 0; 3775 EFI_QUESION_TYPE QType = QUESTION_NORMAL; 3776 UINT8 VarType = EFI_IFR_TYPE_UNDEFINED; 3777 UINT32 VarSize = 0; 3778 Info.mVarStoreId = 0; 3779 >> 3780 L:Get 3781 "\(" 3782 vfrStorageVarId[Info, VarIdStr, FALSE] 3783 {"\|" FLAGS "=" numericVarStoreType [VarType] } 3784 "\)" << 3785 { 3786 if (Info.mVarStoreId == 0) { 3787 // support Date/Time question 3788 mCVfrQuestionDB.GetQuestionId (NULL, VarIdStr, QId, Mask, &QType); 3789 if (QId == EFI_QUESTION_ID_INVALID || Mask == 0 || QType == QUESTION_NORMAL) { 3790 _PCATCH(VFR_RETURN_UNSUPPORTED, L->getLine(), "Get/Set opcode can't get the enough varstore information"); 3791 } 3792 if (QType == QUESTION_DATE) { 3793 Info.mVarType = EFI_IFR_TYPE_DATE; 3794 } else if (QType == QUESTION_TIME) { 3795 Info.mVarType = EFI_IFR_TYPE_TIME; 3796 } 3797 switch (Mask) { 3798 case DATE_YEAR_BITMASK: 3799 Info.mInfo.mVarOffset = 0; 3800 break; 3801 case DATE_DAY_BITMASK: 3802 Info.mInfo.mVarOffset = 3; 3803 break; 3804 case TIME_HOUR_BITMASK: 3805 Info.mInfo.mVarOffset = 0; 3806 break; 3807 case TIME_MINUTE_BITMASK: 3808 Info.mInfo.mVarOffset = 1; 3809 break; 3810 case TIME_SECOND_BITMASK: 3811 Info.mInfo.mVarOffset = 2; 3812 break; 3813 default: 3814 _PCATCH(VFR_RETURN_UNSUPPORTED, L->getLine(), "Get/Set opcode can't get the enough varstore information"); 3815 break; 3816 } 3817 } else { 3818 if ((mCVfrDataStorage.GetVarStoreType(Info.mVarStoreId) == EFI_VFR_VARSTORE_NAME) && (VarType == EFI_IFR_TYPE_UNDEFINED)) { 3819 _PCATCH(VFR_RETURN_UNSUPPORTED, L->getLine(), "Get/Set opcode don't support name string"); 3820 } 3821 if (VarType != EFI_IFR_TYPE_UNDEFINED) { 3822 Info.mVarType = VarType; 3823 _PCATCH(gCVfrVarDataTypeDB.GetDataTypeSize (Info.mVarType, &VarSize), L->getLine(), "Get/Set opcode can't get var type size"); 3824 Info.mVarTotalSize = VarSize; 3825 } 3826 _PCATCH(gCVfrVarDataTypeDB.GetDataTypeSize (Info.mVarType, &VarSize), L->getLine(), "Get/Set opcode can't get var type size"); 3827 if (VarSize != Info.mVarTotalSize) { 3828 _PCATCH(VFR_RETURN_UNSUPPORTED, L->getLine(), "Get/Set opcode don't support data array"); 3829 } 3830 } 3831 CIfrGet GObj(L->getLine()); 3832 _SAVE_OPHDR_COND (GObj, ($ExpOpCount == 0), L->getLine()); 3833 GObj.SetVarInfo (&Info); 3834 delete VarIdStr; 3835 $ExpOpCount++; 3836 } 3837 >> 3838 ; 3839 3840vfrExpressionConstant[UINT32 & RootLevel, UINT32 & ExpOpCount] : 3841 L1:True << CIfrTrue TObj(L1->getLine()); _SAVE_OPHDR_COND (TObj, ($ExpOpCount == 0), L1->getLine()); $ExpOpCount++; >> 3842 | L2:False << CIfrFalse FObj(L2->getLine()); _SAVE_OPHDR_COND (FObj, ($ExpOpCount == 0), L2->getLine()); $ExpOpCount++; >> 3843 | L3:One << CIfrOne OObj(L3->getLine()); _SAVE_OPHDR_COND (OObj, ($ExpOpCount == 0), L3->getLine()); $ExpOpCount++; >> 3844 | L4:Ones << CIfrOnes OObj(L4->getLine()); _SAVE_OPHDR_COND (OObj, ($ExpOpCount == 0), L4->getLine()); $ExpOpCount++; >> 3845 | L5:Zero << CIfrZero ZObj(L5->getLine()); _SAVE_OPHDR_COND (ZObj, ($ExpOpCount == 0), L5->getLine()); $ExpOpCount++; >> 3846 | L6:Undefined << CIfrUndefined UObj(L6->getLine()); _SAVE_OPHDR_COND (UObj, ($ExpOpCount == 0), L6->getLine()); $ExpOpCount++; >> 3847 | L7:Version << CIfrVersion VObj(L7->getLine()); _SAVE_OPHDR_COND (VObj, ($ExpOpCount == 0), L7->getLine()); $ExpOpCount++; >> 3848 | V:Number << CIfrUint64 U64Obj(V->getLine()); U64Obj.SetValue (_STOU64(V->getText(), V->getLine())); _SAVE_OPHDR_COND (U64Obj, ($ExpOpCount == 0), V->getLine()); $ExpOpCount++; >> 3849 ; 3850 3851vfrExpressionUnaryOp[UINT32 & RootLevel, UINT32 & ExpOpCount] : 3852 lengthExp[$RootLevel, $ExpOpCount] 3853 | bitwisenotExp[$RootLevel, $ExpOpCount] 3854 | question23refExp[$RootLevel, $ExpOpCount] 3855 | stringref2Exp[$RootLevel, $ExpOpCount] 3856 | toboolExp[$RootLevel, $ExpOpCount] 3857 | tostringExp[$RootLevel, $ExpOpCount] 3858 | unintExp[$RootLevel, $ExpOpCount] 3859 | toupperExp[$RootLevel, $ExpOpCount] 3860 | tolwerExp[$RootLevel, $ExpOpCount] 3861 | setExp[$RootLevel, $ExpOpCount] 3862 ; 3863 3864lengthExp[UINT32 & RootLevel, UINT32 & ExpOpCount] : 3865 L:Length 3866 "\(" vfrStatementExpressionSub[$RootLevel + 1, $ExpOpCount] "\)" 3867 << { CIfrLength LObj(L->getLine()); $ExpOpCount++; } >> 3868 ; 3869 3870bitwisenotExp[UINT32 & RootLevel, UINT32 & ExpOpCount] : 3871 L:BitWiseNot 3872 "\(" vfrStatementExpressionSub[$RootLevel + 1, $ExpOpCount] "\)" 3873 << { CIfrBitWiseNot BWNObj(L->getLine()); $ExpOpCount++; } >> 3874 ; 3875 3876question23refExp[UINT32 & RootLevel, UINT32 & ExpOpCount] : 3877 << 3878 UINT8 Type = 0x1; 3879 EFI_STRING_ID DevPath = EFI_STRING_ID_INVALID; 3880 EFI_GUID Guid = {0,}; 3881 >> 3882 L:QuestionRefVal 3883 "\(" 3884 { 3885 DevicePath "=" "STRING_TOKEN" "\(" S:Number "\)" "," << Type = 0x2; DevPath = _STOSID(S->getText(), S->getLine()); >> 3886 } 3887 { 3888 Uuid "=" guidDefinition[Guid] "," << Type = 0x3; >> 3889 } 3890 vfrStatementExpressionSub[$RootLevel + 1, $ExpOpCount] 3891 "\)" 3892 << 3893 switch (Type) { 3894 case 0x1: {CIfrQuestionRef2 QR2Obj(L->getLine()); _SAVE_OPHDR_COND (QR2Obj, ($ExpOpCount == 0), L->getLine()); break;} 3895 case 0x2: {CIfrQuestionRef3_2 QR3_2Obj(L->getLine()); _SAVE_OPHDR_COND (QR3_2Obj, ($ExpOpCount == 0), L->getLine()); QR3_2Obj.SetDevicePath (DevPath); break;} 3896 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;} 3897 } 3898 $ExpOpCount++; 3899 >> 3900 ; 3901 3902stringref2Exp[UINT32 & RootLevel, UINT32 & ExpOpCount] : 3903 L:StringRefVal 3904 "\(" vfrStatementExpressionSub[$RootLevel + 1, $ExpOpCount] "\)" 3905 << { CIfrStringRef2 SR2Obj(L->getLine()); $ExpOpCount++; } >> 3906 ; 3907 3908toboolExp[UINT32 & RootLevel, UINT32 & ExpOpCount] : 3909 L:BoolVal 3910 "\(" vfrStatementExpressionSub[$RootLevel + 1, $ExpOpCount] "\)" 3911 << { CIfrToBoolean TBObj(L->getLine()); $ExpOpCount++; } >> 3912 ; 3913 3914tostringExp[UINT32 & RootLevel, UINT32 & ExpOpCount] : 3915 << UINT8 Fmt = 0; >> 3916 L:StringVal 3917 { 3918 Format "=" F:Number "," << Fmt = _STOU8(F->getText(), F->getLine()); >> 3919 } 3920 "\(" vfrStatementExpressionSub[$RootLevel + 1, $ExpOpCount] "\)" 3921 << { CIfrToString TSObj(L->getLine()); TSObj.SetFormat (Fmt); $ExpOpCount++; } >> 3922 ; 3923 3924unintExp[UINT32 & RootLevel, UINT32 & ExpOpCount] : 3925 L:UnIntVal 3926 "\(" vfrStatementExpressionSub[$RootLevel + 1, $ExpOpCount] "\)" 3927 << { CIfrToUint TUObj(L->getLine()); $ExpOpCount++; } >> 3928 ; 3929 3930toupperExp[UINT32 & RootLevel, UINT32 & ExpOpCount] : 3931 L:ToUpper 3932 "\(" vfrStatementExpressionSub[$RootLevel + 1, $ExpOpCount] "\)" 3933 << { CIfrToUpper TUObj(L->getLine()); $ExpOpCount++; } >> 3934 ; 3935 3936tolwerExp[UINT32 & RootLevel, UINT32 & ExpOpCount] : 3937 L:ToLower 3938 "\(" vfrStatementExpressionSub[$RootLevel + 1, $ExpOpCount] "\)" 3939 << { CIfrToLower TLObj(L->getLine()); $ExpOpCount++; } >> 3940 ; 3941 3942setExp[UINT32 & RootLevel, UINT32 & ExpOpCount] : 3943 << 3944 EFI_VARSTORE_INFO Info; 3945 CHAR8 *VarIdStr = NULL; 3946 EFI_QUESTION_ID QId = EFI_QUESTION_ID_INVALID; 3947 UINT32 Mask = 0; 3948 EFI_QUESION_TYPE QType = QUESTION_NORMAL; 3949 UINT8 VarType = EFI_IFR_TYPE_UNDEFINED; 3950 UINT32 VarSize = 0; 3951 Info.mVarStoreId = 0; 3952 >> 3953 L:Set 3954 "\(" 3955 vfrStorageVarId[Info, VarIdStr, FALSE] 3956 {"\|" FLAG "=" numericVarStoreType [VarType] } 3957 "," vfrStatementExpressionSub[$RootLevel + 1, $ExpOpCount] 3958 "\)" 3959 << 3960 { 3961 if (Info.mVarStoreId == 0) { 3962 // support Date/Time question 3963 mCVfrQuestionDB.GetQuestionId (NULL, VarIdStr, QId, Mask, &QType); 3964 if (QId == EFI_QUESTION_ID_INVALID || Mask == 0 || QType == QUESTION_NORMAL) { 3965 _PCATCH(VFR_RETURN_UNSUPPORTED, L->getLine(), "Get/Set opcode can't get the enough varstore information"); 3966 } 3967 if (QType == QUESTION_DATE) { 3968 Info.mVarType = EFI_IFR_TYPE_DATE; 3969 } else if (QType == QUESTION_TIME) { 3970 Info.mVarType = EFI_IFR_TYPE_TIME; 3971 } 3972 switch (Mask) { 3973 case DATE_YEAR_BITMASK: 3974 Info.mInfo.mVarOffset = 0; 3975 break; 3976 case DATE_DAY_BITMASK: 3977 Info.mInfo.mVarOffset = 3; 3978 break; 3979 case TIME_HOUR_BITMASK: 3980 Info.mInfo.mVarOffset = 0; 3981 break; 3982 case TIME_MINUTE_BITMASK: 3983 Info.mInfo.mVarOffset = 1; 3984 break; 3985 case TIME_SECOND_BITMASK: 3986 Info.mInfo.mVarOffset = 2; 3987 break; 3988 default: 3989 _PCATCH(VFR_RETURN_UNSUPPORTED, L->getLine(), "Get/Set opcode can't get the enough varstore information"); 3990 break; 3991 } 3992 } else { 3993 if ((mCVfrDataStorage.GetVarStoreType(Info.mVarStoreId) == EFI_VFR_VARSTORE_NAME) && (VarType == EFI_IFR_TYPE_UNDEFINED)) { 3994 _PCATCH(VFR_RETURN_UNSUPPORTED, L->getLine(), "Get/Set opcode don't support name string"); 3995 } 3996 if (VarType != EFI_IFR_TYPE_UNDEFINED) { 3997 Info.mVarType = VarType; 3998 _PCATCH(gCVfrVarDataTypeDB.GetDataTypeSize (Info.mVarType, &VarSize), L->getLine(), "Get/Set opcode can't get var type size"); 3999 Info.mVarTotalSize = VarSize; 4000 } 4001 _PCATCH(gCVfrVarDataTypeDB.GetDataTypeSize (Info.mVarType, &VarSize), L->getLine(), "Get/Set opcode can't get var type size"); 4002 if (VarSize != Info.mVarTotalSize) { 4003 _PCATCH(VFR_RETURN_UNSUPPORTED, L->getLine(), "Get/Set opcode don't support data array"); 4004 } 4005 } 4006 CIfrSet TSObj(L->getLine()); 4007 TSObj.SetVarInfo (&Info); 4008 delete VarIdStr; 4009 $ExpOpCount++; 4010 } 4011 >> 4012 ; 4013 4014vfrExpressionTernaryOp[UINT32 & RootLevel, UINT32 & ExpOpCount] : 4015 conditionalExp[$RootLevel, $ExpOpCount] 4016 | findExp[$RootLevel, $ExpOpCount] 4017 | midExp[$RootLevel, $ExpOpCount] 4018 | tokenExp[$RootLevel, $ExpOpCount] 4019 | spanExp[$RootLevel, $ExpOpCount] 4020 ; 4021 4022#token Cond("cond") "cond" 4023#token Find("find") "find" 4024#token Mid("mid") "mid" 4025#token Tok("token") "token" 4026#token Span("span") "span" 4027 4028conditionalExp[UINT32 & RootLevel, UINT32 & ExpOpCount] : 4029 L:Cond "\(" 4030 vfrStatementExpressionSub[$RootLevel + 1, $ExpOpCount] 4031 "?" 4032 vfrStatementExpressionSub[$RootLevel + 1, $ExpOpCount] 4033 ":" 4034 vfrStatementExpressionSub[$RootLevel + 1, $ExpOpCount] 4035 "\)" << { CIfrConditional CObj(L->getLine()); $ExpOpCount++; } >> 4036 ; 4037 4038findExp[UINT32 & RootLevel, UINT32 & ExpOpCount] : 4039 << UINT8 Format; >> 4040 L:Find "\(" 4041 findFormat[Format] ( "\|" findFormat[Format] )* 4042 "," 4043 vfrStatementExpressionSub[$RootLevel + 1, $ExpOpCount] 4044 "," 4045 vfrStatementExpressionSub[$RootLevel + 1, $ExpOpCount] 4046 "," 4047 vfrStatementExpressionSub[$RootLevel + 1, $ExpOpCount] 4048 "\)" << { CIfrFind FObj(L->getLine()); FObj.SetFormat (Format); $ExpOpCount++; } >> 4049 ; 4050 4051findFormat [UINT8 & Format] : 4052 "SENSITIVE" << $Format = 0x00; >> 4053 | "INSENSITIVE" << $Format = 0x01; >> 4054 ; 4055 4056midExp[UINT32 & RootLevel, UINT32 & ExpOpCount] : 4057 L:Mid "\(" 4058 vfrStatementExpressionSub[$RootLevel + 1, $ExpOpCount] 4059 "," 4060 vfrStatementExpressionSub[$RootLevel + 1, $ExpOpCount] 4061 "," 4062 vfrStatementExpressionSub[$RootLevel + 1, $ExpOpCount] 4063 "\)" << { CIfrMid MObj(L->getLine()); $ExpOpCount++; } >> 4064 ; 4065 4066tokenExp[UINT32 & RootLevel, UINT32 & ExpOpCount] : 4067 L:Tok "\(" 4068 vfrStatementExpressionSub[$RootLevel + 1, $ExpOpCount] 4069 "," 4070 vfrStatementExpressionSub[$RootLevel + 1, $ExpOpCount] 4071 "," 4072 vfrStatementExpressionSub[$RootLevel + 1, $ExpOpCount] 4073 "\)" << { CIfrToken TObj(L->getLine()); $ExpOpCount++; } >> 4074 ; 4075 4076spanExp[UINT32 & RootLevel, UINT32 & ExpOpCount] : 4077 << UINT8 Flags = 0; >> 4078 S:Span "\(" 4079 FLAGS "=" spanFlags[Flags] ( "\|" spanFlags[Flags] )* 4080 "," 4081 vfrStatementExpressionSub[$RootLevel + 1, $ExpOpCount] 4082 "," 4083 vfrStatementExpressionSub[$RootLevel + 1, $ExpOpCount] 4084 "," 4085 vfrStatementExpressionSub[$RootLevel + 1, $ExpOpCount] 4086 "\)" << { CIfrSpan SObj(S->getLine()); SObj.SetFlags(Flags); $ExpOpCount++; } >> 4087 ; 4088 4089vfrExpressionMap [UINT32 & RootLevel, UINT32 & ExpOpCount]: 4090 L:Map 4091 "\(" 4092 vfrStatementExpressionSub[$RootLevel + 1, $ExpOpCount] 4093 ":" << { CIfrMap MObj(L->getLine()); } >> 4094 ( 4095 vfrStatementExpression[0] 4096 "," 4097 vfrStatementExpression[0] 4098 ";" 4099 ) * 4100 E:"\)" << { CIfrEnd EObj; EObj.SetLineNo(E->getLine()); $ExpOpCount++; } >> 4101 ; 4102 4103spanFlags [UINT8 & Flags] : 4104 N:Number << $Flags |= _STOU8(N->getText(), N->getLine()); >> 4105 | "LAST_NON_MATCH" << $Flags |= 0x00; >> 4106 | "FIRST_NON_MATCH" << $Flags |= 0x01; >> 4107 ; 4108 4109#token StringIdentifier("string identifier") "[A-Za-z_][A-Za-z_0-9]*" 4110#token Number("numeric value") "(0x[0-9A-Fa-f]+) | [0-9]+" 4111 4112//****************************************************************************** 4113// 4114// Parser class definition. 4115// 4116class EfiVfrParser { 4117<< 4118private: 4119 UINT8 mParserStatus; 4120 BOOLEAN mConstantOnlyInExpression; 4121 4122 CVfrDefaultStore mCVfrDefaultStore; 4123 CVfrDataStorage mCVfrDataStorage; 4124 CVfrQuestionDB mCVfrQuestionDB; 4125 CVfrRulesDB mCVfrRulesDB; 4126 4127 CIfrOpHeader * mCIfrOpHdr[MAX_IFR_EXPRESSION_DEPTH]; 4128 UINT32 mCIfrOpHdrLineNo[MAX_IFR_EXPRESSION_DEPTH]; 4129 UINT8 mCIfrOpHdrIndex; 4130 VOID _SAVE_OPHDR_COND (IN CIfrOpHeader &, IN BOOLEAN, UINT32 LineNo = 0); 4131 VOID _CLEAR_SAVED_OPHDR (VOID); 4132 BOOLEAN _SET_SAVED_OPHDR_SCOPE (VOID); 4133 4134 4135 EFI_VARSTORE_INFO mCurrQestVarInfo; 4136 EFI_GUID *mOverrideClassGuid; 4137 CHAR8* mLastFormEndAddr; 4138 4139// 4140// Whether the question already has default value. 4141// 4142 UINT16 mUsedDefaultArray[EFI_IFR_MAX_DEFAULT_TYPE]; 4143 UINT16 mUsedDefaultCount; 4144 4145// 4146// For framework vfr compatibility 4147// 4148 BOOLEAN mCompatibleMode; 4149 EFI_GUID mFormsetGuid; 4150 4151 VOID _CRT_OP (IN BOOLEAN); 4152 4153 VOID _SAVE_CURRQEST_VARINFO (IN EFI_VARSTORE_INFO &); 4154 EFI_VARSTORE_INFO & _GET_CURRQEST_VARTINFO (VOID); 4155 4156 UINT8 _GET_CURRQEST_DATATYPE (); 4157 UINT32 _GET_CURRQEST_VARSIZE (); 4158 UINT32 _GET_CURRQEST_ARRAY_SIZE(); 4159 VOID CheckDuplicateDefaultValue (IN EFI_DEFAULT_ID, IN ANTLRTokenPtr); 4160 4161public: 4162 VOID _PCATCH (IN INTN, IN INTN, IN ANTLRTokenPtr, IN CONST CHAR8 *); 4163 VOID _PCATCH (IN EFI_VFR_RETURN_CODE); 4164 VOID _PCATCH (IN EFI_VFR_RETURN_CODE, IN ANTLRTokenPtr); 4165 VOID _PCATCH (IN EFI_VFR_RETURN_CODE, IN UINT32); 4166 VOID _PCATCH (IN EFI_VFR_RETURN_CODE, IN UINT32, IN CONST CHAR8 *); 4167 4168 VOID syn (ANTLRAbstractToken *, ANTLRChar *, SetWordType *, ANTLRTokenType, INT32); 4169 4170 CHAR8* TrimHex (IN CHAR8 *, OUT BOOLEAN *); 4171 CHAR8* _U32TOS (IN UINT32); 4172 UINT8 _STOU8 (IN CHAR8 *, IN UINT32); 4173 UINT16 _STOU16 (IN CHAR8 *, IN UINT32); 4174 UINT32 _STOU32 (IN CHAR8 *, IN UINT32); 4175 UINT64 _STOU64 (IN CHAR8 *, IN UINT32); 4176 EFI_HII_DATE _STOD (IN CHAR8 *, IN CHAR8 *, IN CHAR8 *, IN UINT32); 4177 EFI_HII_TIME _STOT (IN CHAR8 *, IN CHAR8 *, IN CHAR8 *, IN UINT32); 4178 EFI_HII_REF _STOR (IN CHAR8 *, IN CHAR8 *, IN EFI_GUID *, IN CHAR8 *, IN UINT32); 4179 4180 EFI_STRING_ID _STOSID (IN CHAR8 *, IN UINT32); 4181 EFI_FORM_ID _STOFID (IN CHAR8 *, IN UINT32); 4182 EFI_QUESTION_ID _STOQID (IN CHAR8 *, IN UINT32); 4183 4184 VOID _STRCAT (IN OUT CHAR8 **, IN CONST CHAR8 *); 4185 4186 VOID _DeclareDefaultLinearVarStore (IN UINT32); 4187 VOID _DeclareStandardDefaultStorage (IN UINT32); 4188 VOID _DeclareDefaultFrameworkVarStore (IN UINT32); 4189 4190 VOID AssignQuestionKey (IN CIfrQuestionHeader &, IN ANTLRTokenPtr); 4191 4192 VOID ConvertIdExpr (IN UINT32 &, IN UINT32, IN EFI_QUESTION_ID, IN CHAR8 *, IN UINT32); 4193 VOID IdEqValDoSpecial (IN UINT32 &, IN UINT32, IN EFI_QUESTION_ID, IN CHAR8 *, IN UINT32, IN UINT16, IN EFI_COMPARE_TYPE); 4194 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); 4195 VOID IdEqListDoSpecial (IN UINT32 &, IN UINT32, IN EFI_QUESTION_ID, IN CHAR8 *, IN UINT32, IN UINT16, IN UINT16 *); 4196 VOID SetOverrideClassGuid (IN EFI_GUID *); 4197// 4198// For framework vfr compatibility 4199// 4200 VOID SetCompatibleMode (IN BOOLEAN); 4201>> 4202} 4203 4204<< 4205VOID 4206EfiVfrParser::_SAVE_OPHDR_COND ( 4207 IN CIfrOpHeader &OpHdr, 4208 IN BOOLEAN Cond, 4209 IN UINT32 LineNo 4210 ) 4211{ 4212 if (Cond == TRUE) { 4213 if (mCIfrOpHdr[mCIfrOpHdrIndex] != NULL) { 4214 return ; 4215 } 4216 mCIfrOpHdr[mCIfrOpHdrIndex] = new CIfrOpHeader(OpHdr); 4217 mCIfrOpHdrLineNo[mCIfrOpHdrIndex] = LineNo; 4218 } 4219} 4220 4221VOID 4222EfiVfrParser::_CLEAR_SAVED_OPHDR ( 4223 VOID 4224 ) 4225{ 4226 mCIfrOpHdr[mCIfrOpHdrIndex] = NULL; 4227 mCIfrOpHdrLineNo[mCIfrOpHdrIndex] = 0; 4228} 4229 4230BOOLEAN 4231EfiVfrParser::_SET_SAVED_OPHDR_SCOPE ( 4232 VOID 4233 ) 4234{ 4235 if (mCIfrOpHdr[mCIfrOpHdrIndex] != NULL) { 4236 mCIfrOpHdr[mCIfrOpHdrIndex]->SetScope (1); 4237 return TRUE; 4238 } 4239 4240 // 4241 // IfrOpHdr is not set, FALSE is return. 4242 // 4243 return FALSE; 4244} 4245 4246VOID 4247EfiVfrParser::_CRT_OP ( 4248 IN BOOLEAN Crt 4249 ) 4250{ 4251 gCreateOp = Crt; 4252} 4253 4254VOID 4255EfiVfrParser::_SAVE_CURRQEST_VARINFO ( 4256 IN EFI_VARSTORE_INFO &Info 4257 ) 4258{ 4259 mCurrQestVarInfo = Info; 4260} 4261 4262EFI_VARSTORE_INFO & 4263EfiVfrParser::_GET_CURRQEST_VARTINFO ( 4264 VOID 4265 ) 4266{ 4267 return mCurrQestVarInfo; 4268} 4269 4270UINT32 4271EfiVfrParser::_GET_CURRQEST_ARRAY_SIZE ( 4272 VOID 4273 ) 4274{ 4275 UINT8 Size = 1; 4276 4277 switch (mCurrQestVarInfo.mVarType) { 4278 case EFI_IFR_TYPE_NUM_SIZE_8: 4279 Size = 1; 4280 break; 4281 4282 case EFI_IFR_TYPE_NUM_SIZE_16: 4283 Size = 2; 4284 break; 4285 4286 case EFI_IFR_TYPE_NUM_SIZE_32: 4287 Size = 4; 4288 break; 4289 4290 case EFI_IFR_TYPE_NUM_SIZE_64: 4291 Size = 8; 4292 break; 4293 4294 default: 4295 break; 4296 } 4297 4298 return (mCurrQestVarInfo.mVarTotalSize / Size); 4299} 4300 4301UINT8 4302EfiVfrParser::_GET_CURRQEST_DATATYPE ( 4303 VOID 4304 ) 4305{ 4306 return mCurrQestVarInfo.mVarType; 4307} 4308 4309UINT32 4310EfiVfrParser::_GET_CURRQEST_VARSIZE ( 4311 VOID 4312 ) 4313{ 4314 return mCurrQestVarInfo.mVarTotalSize; 4315} 4316 4317VOID 4318EfiVfrParser::_PCATCH ( 4319 IN INTN ReturnCode, 4320 IN INTN ExpectCode, 4321 IN ANTLRTokenPtr Tok, 4322 IN CONST CHAR8 *ErrorMsg 4323 ) 4324{ 4325 if (ReturnCode != ExpectCode) { 4326 mParserStatus++; 4327 gCVfrErrorHandle.PrintMsg (Tok->getLine(), Tok->getText(), "Error", ErrorMsg); 4328 } 4329} 4330 4331VOID 4332EfiVfrParser::_PCATCH ( 4333 IN EFI_VFR_RETURN_CODE ReturnCode 4334 ) 4335{ 4336 mParserStatus = mParserStatus + gCVfrErrorHandle.HandleError (ReturnCode); 4337} 4338 4339VOID 4340EfiVfrParser::_PCATCH ( 4341 IN EFI_VFR_RETURN_CODE ReturnCode, 4342 IN ANTLRTokenPtr Tok 4343 ) 4344{ 4345 mParserStatus = mParserStatus + gCVfrErrorHandle.HandleError (ReturnCode, Tok->getLine(), Tok->getText()); 4346} 4347 4348VOID 4349EfiVfrParser::_PCATCH ( 4350 IN EFI_VFR_RETURN_CODE ReturnCode, 4351 IN UINT32 LineNum 4352 ) 4353{ 4354 mParserStatus = mParserStatus + gCVfrErrorHandle.HandleError (ReturnCode, LineNum); 4355} 4356 4357VOID 4358EfiVfrParser::_PCATCH ( 4359 IN EFI_VFR_RETURN_CODE ReturnCode, 4360 IN UINT32 LineNum, 4361 IN CONST CHAR8 *ErrorMsg 4362 ) 4363{ 4364 mParserStatus = mParserStatus + gCVfrErrorHandle.HandleError (ReturnCode, LineNum, (CHAR8 *) ErrorMsg); 4365} 4366 4367VOID 4368EfiVfrParser::syn ( 4369 ANTLRAbstractToken *Tok, 4370 ANTLRChar *Egroup, 4371 SetWordType *Eset, 4372 ANTLRTokenType ETok, 4373 INT32 Huh 4374 ) 4375{ 4376 gCVfrErrorHandle.HandleError (VFR_RETURN_MISMATCHED, Tok->getLine(), Tok->getText()); 4377 4378 mParserStatus += 1; 4379} 4380 4381CHAR8 * 4382EfiVfrParser::TrimHex ( 4383 IN CHAR8 *Str, 4384 OUT BOOLEAN *IsHex 4385 ) 4386{ 4387 *IsHex = FALSE; 4388 4389 while (*Str && *Str == ' ') { 4390 Str++; 4391 } 4392 while (*Str && *Str == '0') { 4393 Str++; 4394 } 4395 if (*Str && (*Str == 'x' || *Str == 'X')) { 4396 Str++; 4397 *IsHex = TRUE; 4398 } 4399 4400 return Str; 4401} 4402 4403CHAR8 * 4404EfiVfrParser::_U32TOS ( 4405 IN UINT32 Value 4406 ) 4407{ 4408 CHAR8 *Str; 4409 Str = new CHAR8[20]; 4410 sprintf (Str, "%d", Value); 4411 return Str; 4412} 4413 4414UINT8 4415EfiVfrParser::_STOU8 ( 4416 IN CHAR8 *Str, 4417 IN UINT32 LineNum 4418 ) 4419{ 4420 BOOLEAN IsHex; 4421 UINT8 Value; 4422 CHAR8 c; 4423 4424 UINT8 PreviousValue; 4425 CHAR8 *OrigString = Str; 4426 CHAR8 ErrorMsg[100]; 4427 4428 Str = TrimHex (Str, &IsHex); 4429 for (Value = 0; (c = *Str) != '\0'; Str++) { 4430 PreviousValue = Value; 4431 (IsHex == TRUE) ? (Value <<= 4) : (Value *= 10); 4432 4433 if ((IsHex == TRUE) && (c >= 'a') && (c <= 'f')) { 4434 Value += (c - 'a' + 10); 4435 } 4436 if ((IsHex == TRUE) && (c >= 'A') && (c <= 'F')) { 4437 Value += (c - 'A' + 10); 4438 } 4439 if (c >= '0' && c <= '9') { 4440 Value += (c - '0'); 4441 } 4442 if((IsHex && ((Value/16) != PreviousValue)) || (!IsHex && ((Value/10) != PreviousValue))) { 4443 sprintf(ErrorMsg, "Overflow: Value %s is too large to store in a UINT8", OrigString); 4444 gCVfrErrorHandle.HandleWarning (VFR_WARNING_STRING_TO_UINT_OVERFLOW, LineNum, ErrorMsg); 4445 } 4446 } 4447 4448 return Value; 4449} 4450 4451UINT16 4452EfiVfrParser::_STOU16 ( 4453 IN CHAR8 *Str, 4454 IN UINT32 LineNum 4455 ) 4456{ 4457 BOOLEAN IsHex; 4458 UINT16 Value; 4459 CHAR8 c; 4460 4461 UINT16 PreviousValue; 4462 CHAR8 *OrigString = Str; 4463 CHAR8 ErrorMsg[100]; 4464 4465 Str = TrimHex (Str, &IsHex); 4466 for (Value = 0; (c = *Str) != '\0'; Str++) { 4467 PreviousValue = Value; 4468 (IsHex == TRUE) ? (Value <<= 4) : (Value *= 10); 4469 4470 if ((IsHex == TRUE) && (c >= 'a') && (c <= 'f')) { 4471 Value += (c - 'a' + 10); 4472 } 4473 if ((IsHex == TRUE) && (c >= 'A') && (c <= 'F')) { 4474 Value += (c - 'A' + 10); 4475 } 4476 if (c >= '0' && c <= '9') { 4477 Value += (c - '0'); 4478 } 4479 if((IsHex && ((Value/16) != PreviousValue)) || (!IsHex && ((Value/10) != PreviousValue))) { 4480 sprintf(ErrorMsg, "Overflow: Value %s is too large to store in a UINT16", OrigString); 4481 gCVfrErrorHandle.HandleWarning (VFR_WARNING_STRING_TO_UINT_OVERFLOW, LineNum, ErrorMsg); 4482 } 4483 } 4484 4485 return Value; 4486} 4487 4488UINT32 4489EfiVfrParser::_STOU32 ( 4490 IN CHAR8 *Str, 4491 IN UINT32 LineNum 4492 ) 4493{ 4494 BOOLEAN IsHex; 4495 UINT32 Value; 4496 CHAR8 c; 4497 4498 UINT32 PreviousValue; 4499 CHAR8 *OrigString = Str; 4500 CHAR8 ErrorMsg[100]; 4501 4502 Str = TrimHex (Str, &IsHex); 4503 for (Value = 0; (c = *Str) != '\0'; Str++) { 4504 PreviousValue = Value; 4505 (IsHex == TRUE) ? (Value <<= 4) : (Value *= 10); 4506 4507 if ((IsHex == TRUE) && (c >= 'a') && (c <= 'f')) { 4508 Value += (c - 'a' + 10); 4509 } 4510 if ((IsHex == TRUE) && (c >= 'A') && (c <= 'F')) { 4511 Value += (c - 'A' + 10); 4512 } 4513 if (c >= '0' && c <= '9') { 4514 Value += (c - '0'); 4515 } 4516 if((IsHex && ((Value/16) != PreviousValue)) || (!IsHex && ((Value/10) != PreviousValue ))) { 4517 sprintf(ErrorMsg, "Overflow: Value %s is too large to store in a UINT32", OrigString); 4518 gCVfrErrorHandle.HandleWarning (VFR_WARNING_STRING_TO_UINT_OVERFLOW, LineNum, ErrorMsg); 4519 } 4520 } 4521 4522 return Value; 4523} 4524 4525UINT64 4526EfiVfrParser::_STOU64 ( 4527 IN CHAR8 *Str, 4528 IN UINT32 LineNum 4529 ) 4530{ 4531 BOOLEAN IsHex; 4532 UINT64 Value; 4533 CHAR8 c; 4534 UINT64 PreviousValue; 4535 CHAR8 *OrigString = Str; 4536 CHAR8 ErrorMsg[100]; 4537 4538 Str = TrimHex (Str, &IsHex); 4539 for (Value = 0; (c = *Str) != '\0'; Str++) { 4540 PreviousValue = Value; 4541 (IsHex == TRUE) ? (Value <<= 4) : (Value *= 10); 4542 4543 if ((IsHex == TRUE) && (c >= 'a') && (c <= 'f')) { 4544 Value += (c - 'a' + 10); 4545 } 4546 if ((IsHex == TRUE) && (c >= 'A') && (c <= 'F')) { 4547 Value += (c - 'A' + 10); 4548 } 4549 if (c >= '0' && c <= '9') { 4550 Value += (c - '0'); 4551 } 4552 if((IsHex && ((Value/16) != PreviousValue)) || ((!IsHex && (Value/10) != PreviousValue))) { 4553 sprintf(ErrorMsg, "Overflow: Value %s is too large to store in a UINT64", OrigString); 4554 gCVfrErrorHandle.HandleWarning (VFR_WARNING_STRING_TO_UINT_OVERFLOW, LineNum, ErrorMsg); 4555 } 4556 } 4557 4558 return Value; 4559} 4560 4561EFI_HII_DATE 4562EfiVfrParser::_STOD ( 4563 IN CHAR8 *Year, 4564 IN CHAR8 *Month, 4565 IN CHAR8 *Day, 4566 IN UINT32 LineNum 4567 ) 4568{ 4569 EFI_HII_DATE Date; 4570 4571 Date.Year = _STOU16 (Year, LineNum); 4572 Date.Month = _STOU8 (Month, LineNum); 4573 Date.Day = _STOU8 (Day, LineNum); 4574 4575 return Date; 4576} 4577 4578EFI_HII_TIME 4579EfiVfrParser::_STOT ( 4580 IN CHAR8 *Hour, 4581 IN CHAR8 *Minute, 4582 IN CHAR8 *Second, 4583 IN UINT32 LineNum 4584 ) 4585{ 4586 EFI_HII_TIME Time; 4587 4588 Time.Hour = _STOU8 (Hour, LineNum); 4589 Time.Minute = _STOU8 (Minute, LineNum); 4590 Time.Second = _STOU8 (Second, LineNum); 4591 4592 return Time; 4593} 4594 4595EFI_STRING_ID 4596EfiVfrParser::_STOSID ( 4597 IN CHAR8 *Str, 4598 IN UINT32 LineNum 4599 ) 4600{ 4601 return (EFI_STRING_ID)_STOU16(Str, LineNum); 4602} 4603 4604EFI_FORM_ID 4605EfiVfrParser::_STOFID ( 4606 IN CHAR8 *Str, 4607 IN UINT32 LineNum 4608 ) 4609{ 4610 return (EFI_FORM_ID)_STOU16(Str, LineNum); 4611} 4612 4613EFI_QUESTION_ID 4614EfiVfrParser::_STOQID ( 4615 IN CHAR8 *Str, 4616 IN UINT32 LineNum 4617 ) 4618{ 4619 return (EFI_QUESTION_ID)_STOU16(Str, LineNum); 4620} 4621 4622VOID 4623EfiVfrParser::_STRCAT ( 4624 IN OUT CHAR8 **Dest, 4625 IN CONST CHAR8 *Src 4626 ) 4627{ 4628 CHAR8 *NewStr; 4629 UINT32 Len; 4630 4631 if ((Dest == NULL) || (Src == NULL)) { 4632 return; 4633 } 4634 4635 Len = (*Dest == NULL) ? 0 : strlen (*Dest); 4636 Len += strlen (Src); 4637 if ((NewStr = new CHAR8[Len + 1]) == NULL) { 4638 return; 4639 } 4640 NewStr[0] = '\0'; 4641 if (*Dest != NULL) { 4642 strcpy (NewStr, *Dest); 4643 delete *Dest; 4644 } 4645 strcat (NewStr, Src); 4646 4647 *Dest = NewStr; 4648} 4649 4650EFI_HII_REF 4651EfiVfrParser::_STOR ( 4652 IN CHAR8 *QuestionId, 4653 IN CHAR8 *FormId, 4654 IN EFI_GUID *FormSetGuid, 4655 IN CHAR8 *DevicePath, 4656 IN UINT32 LineNum 4657 ) 4658{ 4659 EFI_HII_REF Ref; 4660 UINT32 Index; 4661 4662 memcpy (&Ref.FormSetGuid, FormSetGuid, sizeof (EFI_GUID)); 4663 Ref.QuestionId = _STOQID (QuestionId, LineNum); 4664 Ref.FormId = _STOFID (FormId, LineNum); 4665 Ref.DevicePath = _STOSID (DevicePath, LineNum); 4666 4667 return Ref; 4668} 4669 4670// 4671// framework vfr to default declare varstore for each structure 4672// 4673VOID 4674EfiVfrParser::_DeclareDefaultFrameworkVarStore ( 4675 IN UINT32 LineNo 4676 ) 4677{ 4678 SVfrVarStorageNode *pNode; 4679 UINT32 TypeSize; 4680 BOOLEAN FirstNode; 4681 CONST CHAR8 VarName[] = "Setup"; 4682 4683 FirstNode = TRUE; 4684 pNode = mCVfrDataStorage.GetBufferVarStoreList(); 4685 if (pNode == NULL && gCVfrVarDataTypeDB.mFirstNewDataTypeName != NULL) { 4686 // 4687 // Create the default Buffer Var Store when no VarStore is defined. 4688 // its name should be "Setup" 4689 // 4690 gCVfrVarDataTypeDB.GetDataTypeSize (gCVfrVarDataTypeDB.mFirstNewDataTypeName, &TypeSize); 4691 CIfrVarStore VSObj; 4692 VSObj.SetLineNo (LineNo); 4693 VSObj.SetVarStoreId (0x1); //the first and only one Buffer Var Store 4694 VSObj.SetSize ((UINT16) TypeSize); 4695 //VSObj.SetName (gCVfrVarDataTypeDB.mFirstNewDataTypeName); 4696 VSObj.SetName ((CHAR8 *) VarName); 4697 VSObj.SetGuid (&mFormsetGuid); 4698#ifdef VFREXP_DEBUG 4699 printf ("Create the default VarStoreName is %s\n", gCVfrVarDataTypeDB.mFirstNewDataTypeName); 4700#endif 4701 } else { 4702 for (; pNode != NULL; pNode = pNode->mNext) { 4703 // 4704 // create the default varstore opcode for not declared varstore 4705 // the first varstore name should be "Setup" 4706 // 4707 if (!pNode->mAssignedFlag) { 4708 CIfrVarStore VSObj; 4709 VSObj.SetLineNo (LineNo); 4710 VSObj.SetVarStoreId (pNode->mVarStoreId); 4711 VSObj.SetSize ((UINT16) pNode->mStorageInfo.mDataType->mTotalSize); 4712 if (FirstNode) { 4713 VSObj.SetName ((CHAR8 *) VarName); 4714 FirstNode = FALSE; 4715 } else { 4716 VSObj.SetName (pNode->mVarStoreName); 4717 } 4718 VSObj.SetGuid (&pNode->mGuid); 4719#ifdef VFREXP_DEBUG 4720 printf ("undefined VarStoreName is %s and Id is 0x%x\n", pNode->mVarStoreName, pNode->mVarStoreId); 4721#endif 4722 } 4723 } 4724 } 4725 4726 pNode = mCVfrDataStorage.GetEfiVarStoreList(); 4727 for (; pNode != NULL; pNode = pNode->mNext) { 4728 // 4729 // create the default efi varstore opcode for not exist varstore 4730 // 4731 if (!pNode->mAssignedFlag) { 4732 CIfrVarStoreEfi VSEObj; 4733 VSEObj.SetLineNo (LineNo); 4734 VSEObj.SetAttributes (0x00000002); //hardcode EFI_VARIABLE_BOOTSERVICE_ACCESS attribute 4735 VSEObj.SetGuid (&pNode->mGuid); 4736 VSEObj.SetVarStoreId (pNode->mVarStoreId); 4737 // Generate old efi varstore storage structure for compatiable with old "VarEqVal" opcode, 4738 // which is 3 bytes less than new structure define in UEFI Spec 2.3.1. 4739 VSEObj.SetBinaryLength (sizeof (EFI_IFR_VARSTORE_EFI) - 3); 4740#ifdef VFREXP_DEBUG 4741 printf ("undefined Efi VarStoreName is %s and Id is 0x%x\n", pNode->mVarStoreName, pNode->mVarStoreId); 4742#endif 4743 } 4744 } 4745 4746} 4747 4748VOID 4749EfiVfrParser::_DeclareDefaultLinearVarStore ( 4750 IN UINT32 LineNo 4751 ) 4752{ 4753 UINT32 Index; 4754 CHAR8 **TypeNameList; 4755 UINT32 ListSize; 4756 CONST CHAR8 DateName[] = "Date"; 4757 CONST CHAR8 TimeName[] = "Time"; 4758 CONST CHAR8 DateType[] = "EFI_HII_DATE"; 4759 CONST CHAR8 TimeType[] = "EFI_HII_TIME"; 4760 4761 gCVfrVarDataTypeDB.GetUserDefinedTypeNameList (&TypeNameList, &ListSize); 4762 4763 for (Index = 0; Index < ListSize; Index++) { 4764 UINT32 Size; 4765 EFI_VARSTORE_ID VarStoreId; 4766 CIfrVarStore VSObj; 4767 4768 VSObj.SetLineNo (LineNo); 4769 mCVfrDataStorage.DeclareBufferVarStore ( 4770 TypeNameList[Index], 4771 &mFormsetGuid, 4772 &gCVfrVarDataTypeDB, 4773 TypeNameList[Index], 4774 EFI_VARSTORE_ID_INVALID 4775 ); 4776 mCVfrDataStorage.GetVarStoreId(TypeNameList[Index], &VarStoreId, &mFormsetGuid); 4777 VSObj.SetVarStoreId (VarStoreId); 4778 gCVfrVarDataTypeDB.GetDataTypeSize(TypeNameList[Index], &Size); 4779 VSObj.SetSize ((UINT16) Size); 4780 VSObj.SetName (TypeNameList[Index]); 4781 VSObj.SetGuid (&mFormsetGuid); 4782 } 4783 4784// 4785// not required to declare Date and Time VarStore, 4786// because code to support old format Data and Time 4787// 4788 if (gCVfrVarDataTypeDB.IsTypeNameDefined ((CHAR8 *) DateName) == FALSE) { 4789 UINT32 Size; 4790 EFI_VARSTORE_ID VarStoreId; 4791 CIfrVarStore VSObj; 4792 4793 VSObj.SetLineNo (LineNo); 4794 mCVfrDataStorage.DeclareBufferVarStore ( 4795 (CHAR8 *) DateName, 4796 &mFormsetGuid, 4797 &gCVfrVarDataTypeDB, 4798 (CHAR8 *) DateType, 4799 EFI_VARSTORE_ID_INVALID 4800 ); 4801 mCVfrDataStorage.GetVarStoreId((CHAR8 *) DateName, &VarStoreId, &mFormsetGuid); 4802 VSObj.SetVarStoreId (VarStoreId); 4803 gCVfrVarDataTypeDB.GetDataTypeSize((CHAR8 *) DateType, &Size); 4804 VSObj.SetSize ((UINT16) Size); 4805 VSObj.SetName ((CHAR8 *) DateName); 4806 VSObj.SetGuid (&mFormsetGuid); 4807 } 4808 4809 if (gCVfrVarDataTypeDB.IsTypeNameDefined ((CHAR8 *) TimeName) == FALSE) { 4810 UINT32 Size; 4811 EFI_VARSTORE_ID VarStoreId; 4812 CIfrVarStore VSObj; 4813 4814 VSObj.SetLineNo (LineNo); 4815 mCVfrDataStorage.DeclareBufferVarStore ( 4816 (CHAR8 *) TimeName, 4817 &mFormsetGuid, 4818 &gCVfrVarDataTypeDB, 4819 (CHAR8 *) TimeType, 4820 EFI_VARSTORE_ID_INVALID 4821 ); 4822 mCVfrDataStorage.GetVarStoreId((CHAR8 *) TimeName, &VarStoreId, &mFormsetGuid); 4823 VSObj.SetVarStoreId (VarStoreId); 4824 gCVfrVarDataTypeDB.GetDataTypeSize((CHAR8 *) TimeType, &Size); 4825 VSObj.SetSize ((UINT16) Size); 4826 VSObj.SetName ((CHAR8 *) TimeName); 4827 VSObj.SetGuid (&mFormsetGuid); 4828 } 4829} 4830 4831VOID 4832EfiVfrParser::_DeclareStandardDefaultStorage ( 4833 IN UINT32 LineNo 4834 ) 4835{ 4836 // 4837 // Default Store is declared. 4838 // 4839 CIfrDefaultStore DSObj; 4840 4841 mCVfrDefaultStore.RegisterDefaultStore (DSObj.GetObjBinAddr(), (CHAR8 *) "Standard Defaults", EFI_STRING_ID_INVALID, EFI_HII_DEFAULT_CLASS_STANDARD); 4842 DSObj.SetLineNo (LineNo); 4843 DSObj.SetDefaultName (EFI_STRING_ID_INVALID); 4844 DSObj.SetDefaultId (EFI_HII_DEFAULT_CLASS_STANDARD); 4845 4846 // 4847 // Default MANUFACTURING Store is declared. 4848 // 4849 CIfrDefaultStore DSObjMF; 4850 4851 mCVfrDefaultStore.RegisterDefaultStore (DSObjMF.GetObjBinAddr(), (CHAR8 *) "Standard ManuFacturing", EFI_STRING_ID_INVALID, EFI_HII_DEFAULT_CLASS_MANUFACTURING); 4852 DSObjMF.SetLineNo (LineNo); 4853 DSObjMF.SetDefaultName (EFI_STRING_ID_INVALID); 4854 DSObjMF.SetDefaultId (EFI_HII_DEFAULT_CLASS_MANUFACTURING); 4855} 4856 4857VOID 4858EfiVfrParser::AssignQuestionKey ( 4859 IN CIfrQuestionHeader &QHObj, 4860 IN ANTLRTokenPtr KeyTok 4861 ) 4862{ 4863 UINT16 KeyValue; 4864 4865 if (KeyTok == NULL) { 4866 return; 4867 } 4868 4869 KeyValue = _STOU16 (KeyTok->getText(), KeyTok->getLine()); 4870 4871 if (QHObj.FLAGS () & EFI_IFR_FLAG_CALLBACK) { 4872 /* 4873 * if the question is not CALLBACK ignore the key. 4874 */ 4875 _PCATCH(mCVfrQuestionDB.UpdateQuestionId (QHObj.QUESTION_ID(), KeyValue), KeyTok); 4876 QHObj.SetQuestionId (KeyValue); 4877 } 4878} 4879 4880VOID 4881EfiVfrParser::ConvertIdExpr ( 4882 IN UINT32 &ExpOpCount, 4883 IN UINT32 LineNo, 4884 IN EFI_QUESTION_ID QId, 4885 IN CHAR8 *VarIdStr, 4886 IN UINT32 BitMask 4887 ) 4888{ 4889 CIfrQuestionRef1 QR1Obj(LineNo); 4890 QR1Obj.SetQuestionId (QId, VarIdStr, LineNo); 4891 _SAVE_OPHDR_COND (QR1Obj, (ExpOpCount == 0)); 4892 4893 if (BitMask != 0) { 4894 CIfrUint32 U32Obj(LineNo); 4895 U32Obj.SetValue (BitMask); 4896 4897 CIfrBitWiseAnd BWAObj(LineNo); 4898 4899 CIfrUint8 U8Obj(LineNo); 4900 switch (BitMask) { 4901 case DATE_YEAR_BITMASK : U8Obj.SetValue (0); break; 4902 case TIME_SECOND_BITMASK : U8Obj.SetValue (0x10); break; 4903 case DATE_DAY_BITMASK : U8Obj.SetValue (0x18); break; 4904 case TIME_HOUR_BITMASK : U8Obj.SetValue (0); break; 4905 case TIME_MINUTE_BITMASK : U8Obj.SetValue (0x8); break; 4906 } 4907 4908 CIfrShiftRight SRObj(LineNo); 4909 } 4910 4911 ExpOpCount += 4; 4912} 4913 4914VOID 4915EfiVfrParser::IdEqValDoSpecial ( 4916 IN UINT32 &ExpOpCount, 4917 IN UINT32 LineNo, 4918 IN EFI_QUESTION_ID QId, 4919 IN CHAR8 *VarIdStr, 4920 IN UINT32 BitMask, 4921 IN UINT16 ConstVal, 4922 IN EFI_COMPARE_TYPE CompareType 4923 ) 4924{ 4925 ConvertIdExpr (ExpOpCount, LineNo, QId, VarIdStr, BitMask); 4926 4927 if (ConstVal > 0xFF) { 4928 CIfrUint16 U16Obj(LineNo); 4929 U16Obj.SetValue (ConstVal); 4930 } else { 4931 CIfrUint8 U8Obj(LineNo); 4932 U8Obj.SetValue ((UINT8)ConstVal); 4933 } 4934 4935 switch (CompareType) { 4936 case EQUAL : 4937 { 4938 CIfrEqual EObj(LineNo); 4939 break; 4940 } 4941 case LESS_EQUAL : 4942 { 4943 CIfrLessEqual LEObj(LineNo); 4944 break; 4945 } 4946 case LESS_THAN : 4947 { 4948 CIfrLessThan LTObj(LineNo); 4949 break; 4950 } 4951 case GREATER_EQUAL : 4952 { 4953 CIfrGreaterEqual GEObj(LineNo); 4954 break; 4955 } 4956 case GREATER_THAN : 4957 { 4958 CIfrGreaterThan GTObj(LineNo); 4959 break; 4960 } 4961 } 4962 4963 ExpOpCount += 2; 4964} 4965 4966VOID 4967EfiVfrParser::IdEqIdDoSpecial ( 4968 IN UINT32 &ExpOpCount, 4969 IN UINT32 LineNo, 4970 IN EFI_QUESTION_ID QId1, 4971 IN CHAR8 *VarId1Str, 4972 IN UINT32 BitMask1, 4973 IN EFI_QUESTION_ID QId2, 4974 IN CHAR8 *VarId2Str, 4975 IN UINT32 BitMask2, 4976 IN EFI_COMPARE_TYPE CompareType 4977 ) 4978{ 4979 ConvertIdExpr (ExpOpCount, LineNo, QId1, VarId1Str, BitMask1); 4980 ConvertIdExpr (ExpOpCount, LineNo, QId2, VarId2Str, BitMask2); 4981 4982 switch (CompareType) { 4983 case EQUAL : 4984 { 4985 CIfrEqual EObj(LineNo); 4986 break; 4987 } 4988 case LESS_EQUAL : 4989 { 4990 CIfrLessEqual LEObj(LineNo); 4991 break; 4992 } 4993 case LESS_THAN : 4994 { 4995 CIfrLessThan LTObj(LineNo); 4996 break; 4997 } 4998 case GREATER_EQUAL : 4999 { 5000 CIfrGreaterEqual GEObj(LineNo); 5001 break; 5002 } 5003 case GREATER_THAN : 5004 { 5005 CIfrGreaterThan GTObj(LineNo); 5006 break; 5007 } 5008 } 5009 5010 ExpOpCount++; 5011} 5012 5013VOID 5014EfiVfrParser::IdEqListDoSpecial ( 5015 IN UINT32 &ExpOpCount, 5016 IN UINT32 LineNo, 5017 IN EFI_QUESTION_ID QId, 5018 IN CHAR8 *VarIdStr, 5019 IN UINT32 BitMask, 5020 IN UINT16 ListLen, 5021 IN UINT16 *ValueList 5022 ) 5023{ 5024 UINT16 Index; 5025 5026 if (ListLen == 0) { 5027 return; 5028 } 5029 5030 IdEqValDoSpecial (ExpOpCount, LineNo, QId, VarIdStr, BitMask, ValueList[0], EQUAL); 5031 for (Index = 1; Index < ListLen; Index++) { 5032 IdEqValDoSpecial (ExpOpCount, LineNo, QId, VarIdStr, BitMask, ValueList[Index], EQUAL); 5033 CIfrOr OObj (LineNo); 5034 ExpOpCount++; 5035 } 5036} 5037 5038VOID 5039EfiVfrParser::SetOverrideClassGuid (IN EFI_GUID *OverrideClassGuid) 5040{ 5041 mOverrideClassGuid = OverrideClassGuid; 5042} 5043 5044// 5045// For framework vfr compatibility 5046// 5047VOID 5048EfiVfrParser::SetCompatibleMode (IN BOOLEAN Mode) 5049{ 5050 mCompatibleMode = Mode; 5051 mCVfrQuestionDB.SetCompatibleMode (Mode); 5052} 5053 5054VOID 5055EfiVfrParser::CheckDuplicateDefaultValue ( 5056 IN EFI_DEFAULT_ID DefaultId, 5057 IN ANTLRTokenPtr Tok 5058 ) 5059{ 5060 UINT16 Index; 5061 5062 for(Index = 0; Index < mUsedDefaultCount; Index++) { 5063 if (mUsedDefaultArray[Index] == DefaultId) { 5064 gCVfrErrorHandle.HandleWarning (VFR_WARNING_DEFAULT_VALUE_REDEFINED, Tok->getLine(), Tok->getText()); 5065 } 5066 } 5067 5068 if (mUsedDefaultCount >= EFI_IFR_MAX_DEFAULT_TYPE - 1) { 5069 gCVfrErrorHandle.HandleError (VFR_RETURN_FATAL_ERROR, Tok->getLine(), Tok->getText()); 5070 } 5071 5072 mUsedDefaultArray[mUsedDefaultCount++] = DefaultId; 5073} 5074>> 5075