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