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