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