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