EdkCompatibilityPkg/Sample/Tools/Source/UefiVfrCompile/VfrFormPkg.h

   1 /*++
   2
   3 Copyright (c) 2004 - 2010, Intel Corporation. All rights reserved.<BR>
   4 This program and the accompanying materials
   5 are licensed and made available under the terms and conditions of the BSD License
   6 which accompanies this distribution.  The full text of the license may be found at
   7 http://opensource.org/licenses/bsd-license.php
   8
   9 THE PROGRAM IS DISTRIBUTED UNDER THE BSD LICENSE ON AN "AS IS" BASIS,
  10 WITHOUT WARRANTIES OR REPRESENTATIONS OF ANY KIND, EITHER EXPRESS OR IMPLIED.
  11
  12 Module Name:
  13
  14 VfrFormPkg.h
  15
  16 Abstract:
  17
  18 --*/
  19
  20 #ifndef _EFIIFRCLASS_H_
  21 #define _EFIIFRCLASS_H_
  22
  23 #include "string.h"
  24 #include "EfiVfr.h"
  25 #include "VfrError.h"
  26 #include "VfrUtilityLib.h"
  27
  28 /*
  29  * The functions below are used for flags setting
  30  */
  31 static inline BOOLEAN _FLAGS_ZERO (
  32   IN UINT8 &Flags
  33   )
  34 {
  35   return Flags == 0;
  36 }
  37
  38 static inline VOID _FLAG_CLEAR (
  39   IN UINT8 &Flags,
  40   IN UINT8 Mask
  41   )
  42 {
  43   Flags &= (~Mask);
  44 }
  45
  46 static inline UINT8 _FLAG_TEST_AND_CLEAR (
  47   IN UINT8 &Flags,
  48   IN UINT8 Mask
  49   )
  50 {
  51   UINT8 Ret = Flags & Mask;
  52   Flags &= (~Mask);
  53   return Ret;
  54 }
  55
  56 static inline UINT8 _IS_EQUAL (
  57   IN UINT8 &Flags,
  58   IN UINT8 Value
  59   )
  60 {
  61   return Flags == Value;
  62 }
  63
  64 /*
  65  * The definition of CIfrBin
  66  */
  67 typedef enum {
  68   PENDING,
  69   ASSIGNED
  70 } ASSIGN_FLAG;
  71
  72 struct SPendingAssign {
  73   INT8                    *mKey;  // key ! unique
  74   VOID                    *mAddr;
  75   UINT32                  mLen;
  76   ASSIGN_FLAG             mFlag;
  77   UINT32                  mLineNo;
  78   struct SPendingAssign   *mNext;
  79
  80   SPendingAssign (IN INT8 *, IN VOID *, IN UINT32, IN UINT32);
  81   ~SPendingAssign ();
  82
  83   VOID   SetAddrAndLen (IN VOID *, IN UINT32);
  84   VOID   AssignValue (IN VOID *, IN UINT32);
  85   INT8 * GetKey (VOID);
  86 };
  87
  88 struct SBufferNode {
  89   CHAR8              *mBufferStart;
  90   CHAR8              *mBufferEnd;
  91   CHAR8              *mBufferFree;
  92   struct SBufferNode *mNext;
  93 };
  94
  95 class CFormPkg {
  96 private:
  97   UINT32              mBufferSize;
  98   SBufferNode         *mBufferNodeQueueHead;
  99   SBufferNode         *mBufferNodeQueueTail;
 100   SBufferNode         *mCurrBufferNode;
 101
 102   SBufferNode         *mReadBufferNode;
 103   UINT32              mReadBufferOffset;
 104
 105   UINT32              mPkgLength;
 106
 107   VOID                _WRITE_PKG_LINE (IN FILE *, IN UINT32 , IN INT8 *, IN INT8 *, IN UINT32);
 108   VOID                _WRITE_PKG_END (IN FILE *, IN UINT32 , IN INT8 *, IN INT8 *, IN UINT32);
 109
 110 private:
 111   SPendingAssign      *PendingAssignList;
 112
 113 public:
 114   CFormPkg (IN UINT32 BufferSize);
 115   ~CFormPkg ();
 116
 117   CHAR8             * IfrBinBufferGet (IN UINT32);
 118   inline UINT32       GetPkgLength (VOID);
 119
 120   VOID                Open ();
 121   UINT32              Read (IN CHAR8 *, IN UINT32);
 122   VOID                Close ();
 123
 124   EFI_VFR_RETURN_CODE BuildPkgHdr (OUT EFI_HII_PACKAGE_HEADER **);
 125   EFI_VFR_RETURN_CODE BuildPkg (IN FILE *);
 126   EFI_VFR_RETURN_CODE GenCFile (IN INT8 *, IN FILE *);
 127
 128 public:
 129   EFI_VFR_RETURN_CODE AssignPending (IN INT8 *, IN VOID *, IN UINT32, IN UINT32);
 130   VOID                DoPendingAssign (IN INT8 *, IN VOID *, IN UINT32);
 131   bool                HavePendingUnassigned (VOID);
 132   VOID                PendingAssignPrintAll (VOID);
 133 };
 134
 135 extern CFormPkg gCFormPkg;
 136
 137 struct SIfrRecord {
 138   UINT32     mLineNo;
 139   CHAR8      *mIfrBinBuf;
 140   UINT8      mBinBufLen;
 141   UINT32     mOffset;
 142   SIfrRecord *mNext;
 143
 144   SIfrRecord (VOID);
 145   ~SIfrRecord (VOID);
 146 };
 147
 148 #define EFI_IFR_RECORDINFO_IDX_INVALUD 0xFFFFFF
 149 #define EFI_IFR_RECORDINFO_IDX_START   0x0
 150
 151 class CIfrRecordInfoDB {
 152 private:
 153   bool       mSwitch;
 154   UINT32     mRecordCount;
 155   SIfrRecord *mIfrRecordListHead;
 156   SIfrRecord *mIfrRecordListTail;
 157
 158   SIfrRecord * GetRecordInfoFromIdx (IN UINT32);
 159 public:
 160   CIfrRecordInfoDB (VOID);
 161   ~CIfrRecordInfoDB (VOID);
 162
 163   inline VOID TurnOn (VOID) {
 164     mSwitch = TRUE;
 165   }
 166
 167   inline VOID TurnOff (VOID) {
 168     mSwitch = FALSE;
 169   }
 170
 171   UINT32      IfrRecordRegister (IN UINT32, IN CHAR8 *, IN UINT8, IN UINT32);
 172   VOID        IfrRecordInfoUpdate (IN UINT32, IN UINT32, IN CHAR8*, IN UINT8, IN UINT32);
 173   VOID        IfrRecordOutput (IN FILE *, IN UINT32 LineNo);
 174 };
 175
 176 extern CIfrRecordInfoDB gCIfrRecordInfoDB;
 177
 178 /*
 179  * The definition of CIfrObj
 180  */
 181 extern bool  gCreateOp;
 182
 183 class CIfrObj {
 184 private:
 185   bool    mDelayEmit;
 186
 187   CHAR8   *mObjBinBuf;
 188   UINT8   mObjBinLen;
 189   UINT32  mLineNo;
 190   UINT32  mRecordIdx;
 191   UINT32  mPkgOffset;
 192
 193   VOID    _EMIT_PENDING_OBJ (VOID);
 194
 195 public:
 196   CIfrObj (IN UINT8 OpCode, OUT CHAR8 **IfrObj = NULL, IN UINT8 ObjBinLen = 0, IN BOOLEAN DelayEmit = FALSE);
 197   virtual ~CIfrObj(VOID);
 198
 199   inline VOID    SetLineNo (IN UINT32 LineNo) {
 200     mLineNo = LineNo;
 201   }
 202
 203   inline CHAR8 * GetObjBinAddr (VOID) {
 204     return mObjBinBuf;
 205   }
 206
 207   inline UINT8   GetObjBinLen (VOID) {
 208     return mObjBinLen;
 209   }
 210
 211   inline bool ExpendObjBin (IN UINT8 Size) {
 212     if ((mDelayEmit == TRUE) && ((mObjBinLen + Size) > mObjBinLen)) {
 213       mObjBinLen += Size;
 214       return TRUE;
 215     } else {
 216       return FALSE;
 217     }
 218   }
 219 };
 220
 221 /*
 222  * The definition of CIfrOpHeader
 223  */
 224 class CIfrOpHeader {
 225 private:
 226   EFI_IFR_OP_HEADER *mHeader;
 227
 228 public:
 229   CIfrOpHeader (IN UINT8 OpCode, IN VOID *StartAddr, IN UINT8 Length = 0);
 230   CIfrOpHeader (IN CIfrOpHeader &);
 231
 232   VOID IncLength (UINT8 Size) {
 233     if ((mHeader->Length + Size) > mHeader->Length) {
 234       mHeader->Length += Size;
 235     }
 236   }
 237
 238   VOID DecLength (UINT8 Size) {
 239     if (mHeader->Length >= Size) {
 240           mHeader -= Size;
 241     }
 242   }
 243
 244   UINT8 GetLength () {
 245     return mHeader->Length;
 246   }
 247
 248   UINT8 GetScope () {
 249     return mHeader->Scope;
 250   }
 251
 252   VOID SetScope (IN UINT8 Scope) {
 253     mHeader->Scope = Scope;
 254   }
 255 };
 256
 257 extern UINT8 gScopeCount;
 258
 259 /*
 260  * The definition of CIfrStatementHeader
 261  */
 262 class CIfrStatementHeader {
 263 private:
 264   EFI_IFR_STATEMENT_HEADER *mHeader;
 265
 266 public:
 267   CIfrStatementHeader (
 268     IN EFI_IFR_STATEMENT_HEADER *StartAddr
 269   ) : mHeader ((EFI_IFR_STATEMENT_HEADER *)StartAddr) {
 270     mHeader         = StartAddr;
 271     mHeader->Help   = EFI_STRING_ID_INVALID;
 272     mHeader->Prompt = EFI_STRING_ID_INVALID;
 273   }
 274
 275   EFI_IFR_STATEMENT_HEADER *GetStatementHeader () {
 276     return mHeader;
 277   }
 278
 279   VOID SetPrompt (IN EFI_STRING_ID Prompt) {
 280     mHeader->Prompt = Prompt;
 281   }
 282
 283   VOID SetHelp (IN EFI_STRING_ID Help) {
 284     mHeader->Help = Help;
 285   }
 286 };
 287
 288 /*
 289  * The definition of CIfrQuestionHeader
 290  */
 291 #define EFI_IFR_QUESTION_FLAG_DEFAULT 0
 292
 293 class CIfrQuestionHeader : public CIfrStatementHeader {
 294 private:
 295   EFI_IFR_QUESTION_HEADER *mHeader;
 296
 297   EFI_IFR_STATEMENT_HEADER * QH2SH (EFI_IFR_QUESTION_HEADER *Qheader) {
 298     return &(Qheader)->Header;
 299   }
 300
 301 public:
 302   EFI_QUESTION_ID QUESTION_ID (VOID) {
 303     return mHeader->QuestionId;
 304   }
 305
 306   EFI_VARSTORE_ID VARSTORE_ID (VOID) {
 307     return mHeader->VarStoreId;
 308   }
 309
 310   VOID VARSTORE_INFO (OUT EFI_VARSTORE_INFO *Info) {
 311     if (Info != NULL) {
 312       Info->mVarStoreId   = mHeader->VarStoreId;
 313       memcpy (&Info->mVarStoreId, &mHeader->VarStoreInfo, sizeof (Info->mVarStoreId));
 314     }
 315   }
 316
 317   UINT8 FLAGS (VOID) {
 318     return mHeader->Flags;
 319   }
 320
 321 public:
 322   CIfrQuestionHeader (
 323     IN EFI_IFR_QUESTION_HEADER *StartAddr,
 324     IN UINT8 Flags = EFI_IFR_QUESTION_FLAG_DEFAULT
 325   ) : CIfrStatementHeader (QH2SH(StartAddr)) {
 326     mHeader                         = StartAddr;
 327     mHeader->QuestionId             = EFI_QUESTION_ID_INVALID;
 328     mHeader->VarStoreId             = EFI_VARSTORE_ID_INVALID;
 329     mHeader->VarStoreInfo.VarName   = EFI_STRING_ID_INVALID;
 330     mHeader->VarStoreInfo.VarOffset = EFI_VAROFFSET_INVALID;
 331     mHeader->Flags                  = Flags;
 332   }
 333
 334   VOID SetQuestionId (IN EFI_QUESTION_ID QuestionId) {
 335     mHeader->QuestionId = QuestionId;
 336   }
 337
 338   VOID SetVarStoreInfo (IN EFI_VARSTORE_INFO *Info) {
 339     mHeader->VarStoreId             = Info->mVarStoreId;
 340         mHeader->VarStoreInfo.VarName   = Info->mInfo.mVarName;
 341     mHeader->VarStoreInfo.VarOffset = Info->mInfo.mVarOffset;
 342   }
 343
 344   EFI_VFR_RETURN_CODE SetFlags (IN UINT8 Flags) {
 345     if (_FLAG_TEST_AND_CLEAR (Flags, EFI_IFR_FLAG_READ_ONLY)) {
 346       mHeader->Flags |= EFI_IFR_FLAG_READ_ONLY;
 347     }
 348
 349     _FLAG_CLEAR (Flags, 0x02);
 350
 351     if (_FLAG_TEST_AND_CLEAR (Flags, EFI_IFR_FLAG_CALLBACK)) {
 352       mHeader->Flags |= EFI_IFR_FLAG_CALLBACK;
 353     }
 354
 355     _FLAG_CLEAR (Flags, 0x08);
 356
 357     if (_FLAG_TEST_AND_CLEAR (Flags, EFI_IFR_FLAG_RESET_REQUIRED)) {
 358       mHeader->Flags |= EFI_IFR_FLAG_RESET_REQUIRED;
 359     }
 360
 361     _FLAG_CLEAR (Flags, 0x20);
 362
 363     if (_FLAG_TEST_AND_CLEAR (Flags, EFI_IFR_FLAG_OPTIONS_ONLY)) {
 364       mHeader->Flags |= EFI_IFR_FLAG_OPTIONS_ONLY;
 365     }
 366
 367     return _FLAGS_ZERO (Flags) ? VFR_RETURN_SUCCESS : VFR_RETURN_FLAGS_UNSUPPORTED;
 368   }
 369 };
 370
 371 static CIfrQuestionHeader *gCurrentQuestion = NULL;
 372
 373 /*
 374  * The definition of CIfrMinMaxStepData
 375  */
 376 class CIfrMinMaxStepData {
 377 private:
 378   MINMAXSTEP_DATA *mMinMaxStepData;
 379
 380 public:
 381   CIfrMinMaxStepData (MINMAXSTEP_DATA *DataAddr) : mMinMaxStepData (DataAddr) {
 382     mMinMaxStepData->u64.MinValue = 0;
 383     mMinMaxStepData->u64.MaxValue = 0;
 384     mMinMaxStepData->u64.Step     = 0;
 385   }
 386
 387   VOID SetMinMaxStepData (IN UINT64 MinValue, IN UINT64 MaxValue, IN UINT64 Step) {
 388     mMinMaxStepData->u64.MinValue = MinValue;
 389     mMinMaxStepData->u64.MaxValue = MaxValue;
 390     mMinMaxStepData->u64.Step     = Step;
 391   }
 392
 393   VOID SetMinMaxStepData (IN UINT32 MinValue, IN UINT32 MaxValue, IN UINT32 Step) {
 394     mMinMaxStepData->u32.MinValue = MinValue;
 395     mMinMaxStepData->u32.MaxValue = MaxValue;
 396     mMinMaxStepData->u32.Step     = Step;
 397   }
 398
 399   VOID SetMinMaxStepData (IN UINT16 MinValue, IN UINT16 MaxValue, IN UINT16 Step) {
 400     mMinMaxStepData->u16.MinValue = MinValue;
 401     mMinMaxStepData->u16.MaxValue = MaxValue;
 402     mMinMaxStepData->u16.Step     = Step;
 403   }
 404
 405   VOID SetMinMaxStepData (IN UINT8 MinValue, IN UINT8 MaxValue, IN UINT8 Step) {
 406     mMinMaxStepData->u8.MinValue = MinValue;
 407     mMinMaxStepData->u8.MaxValue = MaxValue;
 408     mMinMaxStepData->u8.Step     = Step;
 409   }
 410
 411 };
 412
 413 /*
 414  * The definition of all of the UEFI IFR Objects
 415  */
 416 class CIfrFormSet : public CIfrObj, public CIfrOpHeader {
 417 private:
 418   EFI_IFR_FORM_SET *mFormSet;
 419
 420 public:
 421   CIfrFormSet () : CIfrObj (EFI_IFR_FORM_SET_OP, (CHAR8 **)&mFormSet),
 422                    CIfrOpHeader (EFI_IFR_FORM_SET_OP, &mFormSet->Header) {
 423     mFormSet->Help         = EFI_STRING_ID_INVALID;
 424     mFormSet->FormSetTitle = EFI_STRING_ID_INVALID;
 425     memset (&mFormSet->Guid, 0, sizeof (EFI_GUID));
 426   }
 427
 428   VOID SetGuid (IN EFI_GUID *Guid) {
 429     memcpy (&mFormSet->Guid, Guid, sizeof (EFI_GUID));
 430   }
 431
 432   VOID SetFormSetTitle (IN EFI_STRING_ID FormSetTitle) {
 433     mFormSet->FormSetTitle = FormSetTitle;
 434   }
 435
 436   VOID SetHelp (IN EFI_STRING_ID Help) {
 437     mFormSet->Help = Help;
 438   }
 439 };
 440
 441 class CIfrEnd : public CIfrObj, public CIfrOpHeader {
 442 private:
 443   EFI_IFR_END  *mEnd;
 444
 445 public:
 446   CIfrEnd () : CIfrObj (EFI_IFR_END_OP, (CHAR8 **)&mEnd),
 447                CIfrOpHeader (EFI_IFR_END_OP, &mEnd->Header) {}
 448 };
 449
 450 class CIfrDefaultStore : public CIfrObj, public CIfrOpHeader {
 451 private:
 452   EFI_IFR_DEFAULTSTORE *mDefaultStore;
 453
 454 public:
 455   CIfrDefaultStore () : CIfrObj (EFI_IFR_DEFAULTSTORE_OP, (CHAR8 **)&mDefaultStore),
 456                        CIfrOpHeader (EFI_IFR_DEFAULTSTORE_OP, &mDefaultStore->Header) {
 457     mDefaultStore->DefaultId   = EFI_VARSTORE_ID_INVALID;
 458     mDefaultStore->DefaultName = EFI_STRING_ID_INVALID;
 459   }
 460
 461   VOID SetDefaultName (IN EFI_STRING_ID DefaultName) {
 462     mDefaultStore->DefaultName = DefaultName;
 463   }
 464
 465   VOID SetDefaultId (IN UINT16 DefaultId) {
 466     mDefaultStore->DefaultId = DefaultId;
 467   }
 468 };
 469
 470 #define EFI_FORM_ID_MAX                    0xFFFF
 471 #define EFI_FREE_FORM_ID_BITMAP_SIZE     ((EFI_FORM_ID_MAX + 1) / EFI_BITS_PER_UINT32)
 472
 473 class CIfrForm : public CIfrObj, public CIfrOpHeader {
 474 private:
 475   EFI_IFR_FORM  *mForm;
 476
 477   STATIC UINT32 FormIdBitMap[EFI_FREE_FORM_ID_BITMAP_SIZE];
 478
 479   STATIC BOOLEAN ChekFormIdFree (IN EFI_FORM_ID FormId) {
 480     UINT32 Index  = (FormId / EFI_BITS_PER_UINT32);
 481     UINT32 Offset = (FormId % EFI_BITS_PER_UINT32);
 482
 483     return (FormIdBitMap[Index] & (0x80000000 >> Offset)) == 0;
 484   }
 485
 486   STATIC VOID MarkFormIdUsed (IN EFI_FORM_ID FormId) {
 487     UINT32 Index  = (FormId / EFI_BITS_PER_UINT32);
 488     UINT32 Offset = (FormId % EFI_BITS_PER_UINT32);
 489
 490     FormIdBitMap[Index] |= (0x80000000 >> Offset);
 491   }
 492
 493 public:
 494   CIfrForm () : CIfrObj (EFI_IFR_FORM_OP, (CHAR8 **)&mForm),
 495                 CIfrOpHeader (EFI_IFR_FORM_OP, &mForm->Header) {
 496     mForm->FormId    = 0;
 497     mForm->FormTitle = EFI_STRING_ID_INVALID;
 498   }
 499
 500   EFI_VFR_RETURN_CODE SetFormId (IN EFI_FORM_ID FormId) {
 501     if (CIfrForm::ChekFormIdFree (FormId) == FALSE) {
 502       return VFR_RETURN_FORMID_REDEFINED;
 503     }
 504     mForm->FormId = FormId;
 505     CIfrForm::MarkFormIdUsed (FormId);
 506     return VFR_RETURN_SUCCESS;
 507   }
 508
 509   VOID SetFormTitle (IN EFI_STRING_ID FormTitle) {
 510     mForm->FormTitle = FormTitle;
 511   }
 512 };
 513
 514 class CIfrVarStore : public CIfrObj, public CIfrOpHeader {
 515 private:
 516   EFI_IFR_VARSTORE *mVarStore;
 517
 518 public:
 519   CIfrVarStore () : CIfrObj (EFI_IFR_VARSTORE_OP, (CHAR8 **)&mVarStore, sizeof (EFI_IFR_VARSTORE), TRUE),
 520                    CIfrOpHeader (EFI_IFR_VARSTORE_OP, &mVarStore->Header) {
 521     mVarStore->VarStoreId = EFI_VARSTORE_ID_INVALID;
 522     mVarStore->Size       = 0;
 523     memset (&mVarStore->Guid, 0, sizeof (EFI_GUID));
 524     mVarStore->Name[0]    = '\0';
 525   }
 526
 527   VOID SetGuid (IN EFI_GUID *Guid) {
 528     memcpy (&mVarStore->Guid, Guid, sizeof (EFI_GUID));
 529   }
 530
 531   VOID SetVarStoreId (IN EFI_VARSTORE_ID VarStoreId) {
 532     mVarStore->VarStoreId = VarStoreId;
 533   }
 534
 535   VOID SetSize (IN UINT16 Size) {
 536     mVarStore->Size = Size;
 537   }
 538
 539   VOID SetName (IN INT8 *Name) {
 540     UINT8 Len;
 541
 542     if (Name != NULL) {
 543       Len = strlen (Name);
 544       if (Len != 0) {
 545         if (ExpendObjBin (Len) == TRUE) {
 546           IncLength (Len);
 547           strcpy ((INT8 *)(mVarStore->Name), Name);
 548         }
 549       }
 550     }
 551   }
 552 };
 553
 554 class CIfrVarStoreEfi : public CIfrObj, public CIfrOpHeader {
 555 private:
 556   EFI_IFR_VARSTORE_EFI *mVarStoreEfi;
 557
 558 public:
 559   CIfrVarStoreEfi () : CIfrObj (EFI_IFR_VARSTORE_EFI_OP, (CHAR8 **)&mVarStoreEfi),
 560                       CIfrOpHeader (EFI_IFR_VARSTORE_EFI_OP, &mVarStoreEfi->Header) {
 561     mVarStoreEfi->VarStoreId = EFI_VAROFFSET_INVALID;
 562     memset (&mVarStoreEfi->Guid, 0, sizeof (EFI_GUID));
 563   }
 564
 565   VOID SetGuid (IN EFI_GUID *Guid) {
 566     memcpy (&mVarStoreEfi->Guid, Guid, sizeof (EFI_GUID));
 567   }
 568
 569   VOID SetVarStoreId (IN UINT16 VarStoreId) {
 570     mVarStoreEfi->VarStoreId = VarStoreId;
 571   }
 572
 573   VOID SetAttributes (IN UINT32 Attributes) {
 574     mVarStoreEfi->Attributes = Attributes;
 575   }
 576 };
 577
 578 class CIfrVarStoreNameValue : public CIfrObj, public CIfrOpHeader {
 579 private:
 580   EFI_IFR_VARSTORE_NAME_VALUE *mVarStoreNameValue;
 581
 582 public:
 583   CIfrVarStoreNameValue () : CIfrObj (EFI_IFR_VARSTORE_NAME_VALUE_OP, (CHAR8 **)&mVarStoreNameValue),
 584                               CIfrOpHeader (EFI_IFR_VARSTORE_NAME_VALUE_OP, &mVarStoreNameValue->Header) {
 585     mVarStoreNameValue->VarStoreId = EFI_VAROFFSET_INVALID;
 586     memset (&mVarStoreNameValue->Guid, 0, sizeof (EFI_GUID));
 587   }
 588
 589   VOID SetGuid (IN EFI_GUID *Guid) {
 590     memcpy (&mVarStoreNameValue->Guid, Guid, sizeof (EFI_GUID));
 591   }
 592
 593   VOID SetVarStoreId (IN UINT16 VarStoreId) {
 594     mVarStoreNameValue->VarStoreId = VarStoreId;
 595   }
 596 };
 597
 598 class CIfrImage : public CIfrObj, public CIfrOpHeader {
 599 private:
 600   EFI_IFR_IMAGE *mImage;
 601
 602 public:
 603   CIfrImage () : CIfrObj (EFI_IFR_IMAGE_OP, (CHAR8 **)&mImage),
 604                  CIfrOpHeader (EFI_IFR_FORM_OP, &mImage->Header) {
 605     mImage->Id = EFI_IMAGE_ID_INVALID;
 606   }
 607
 608   VOID SetImageId (IN EFI_IMAGE_ID ImageId) {
 609     mImage->Id = ImageId;
 610   }
 611 };
 612
 613 class CIfrLocked : public CIfrObj, public CIfrOpHeader {
 614 private:
 615   EFI_IFR_LOCKED *mLocked;
 616
 617 public:
 618   CIfrLocked () : CIfrObj (EFI_IFR_LOCKED_OP, (CHAR8 **)&mLocked),
 619                   CIfrOpHeader (EFI_IFR_LOCKED_OP, &mLocked->Header) {}
 620 };
 621
 622 class CIfrRule : public CIfrObj, public CIfrOpHeader {
 623 private:
 624   EFI_IFR_RULE *mRule;
 625
 626 public:
 627   CIfrRule () : CIfrObj (EFI_IFR_RULE_OP, (CHAR8 **)&mRule),
 628                 mRule ((EFI_IFR_RULE *)GetObjBinAddr()),
 629                 CIfrOpHeader (EFI_IFR_RULE_OP, &mRule->Header) {
 630     mRule->RuleId = EFI_RULE_ID_INVALID;
 631   }
 632
 633   VOID SetRuleId (IN UINT8 RuleId) {
 634     mRule->RuleId = RuleId;
 635   }
 636 };
 637
 638 static EFI_IFR_TYPE_VALUE gZeroEfiIfrTypeValue = {0, };
 639
 640 class CIfrDefault : public CIfrObj, public CIfrOpHeader {
 641 private:
 642   EFI_IFR_DEFAULT *mDefault;
 643
 644 public:
 645   CIfrDefault (
 646     IN UINT16             DefaultId = EFI_HII_DEFAULT_CLASS_STANDARD,
 647     IN UINT8              Type      = EFI_IFR_TYPE_OTHER,
 648     IN EFI_IFR_TYPE_VALUE Value     = gZeroEfiIfrTypeValue
 649     ) : CIfrObj (EFI_IFR_DEFAULT_OP, (CHAR8 **)&mDefault),
 650         CIfrOpHeader (EFI_IFR_DEFAULT_OP, &mDefault->Header) {
 651     mDefault->Type      = Type;
 652         mDefault->Value     = Value;
 653     mDefault->DefaultId = DefaultId;
 654   }
 655
 656   VOID SetDefaultId (IN UINT16 DefaultId) {
 657     mDefault->DefaultId = DefaultId;
 658   }
 659
 660   VOID SetType (IN UINT8 Type) {
 661     mDefault->Type = Type;
 662   }
 663
 664   VOID SetValue (IN EFI_IFR_TYPE_VALUE Value) {
 665     mDefault->Value = Value;
 666   }
 667 };
 668
 669 class CIfrValue : public CIfrObj, public CIfrOpHeader{
 670 private:
 671   EFI_IFR_VALUE *mValue;
 672
 673 public:
 674   CIfrValue () : CIfrObj (EFI_IFR_VALUE_OP, (CHAR8 **)&mValue),
 675                 CIfrOpHeader (EFI_IFR_VALUE_OP, &mValue->Header) {}
 676
 677 };
 678
 679 class CIfrSubtitle : public CIfrObj, public CIfrOpHeader, public CIfrStatementHeader {
 680 private:
 681   EFI_IFR_SUBTITLE   *mSubtitle;
 682
 683 public:
 684   CIfrSubtitle () : CIfrObj (EFI_IFR_SUBTITLE_OP, (CHAR8 **)&mSubtitle),
 685                   CIfrOpHeader (EFI_IFR_SUBTITLE_OP, &mSubtitle->Header),
 686                                   CIfrStatementHeader (&mSubtitle->Statement) {
 687     mSubtitle->Flags = 0;
 688   }
 689
 690   EFI_VFR_RETURN_CODE SetFlags (IN UINT8 LFlags) {
 691     if (_FLAG_TEST_AND_CLEAR (LFlags, EFI_IFR_FLAGS_HORIZONTAL)) {
 692       mSubtitle->Flags |= EFI_IFR_FLAGS_HORIZONTAL;
 693     }
 694
 695     return _FLAGS_ZERO (LFlags) ? VFR_RETURN_SUCCESS : VFR_RETURN_FLAGS_UNSUPPORTED;
 696   }
 697 };
 698
 699 class CIfrText : public CIfrObj, public CIfrOpHeader, public CIfrStatementHeader {
 700 private:
 701   EFI_IFR_TEXT *mText;
 702
 703 public:
 704   CIfrText () : CIfrObj (EFI_IFR_TEXT_OP, (CHAR8 **)&mText),
 705                CIfrOpHeader (EFI_IFR_TEXT_OP, &mText->Header),
 706                CIfrStatementHeader (&mText->Statement) {
 707     mText->TextTwo = EFI_STRING_ID_INVALID;
 708   }
 709
 710   VOID SetTextTwo (IN EFI_STRING_ID StringId) {
 711     mText->TextTwo = StringId;
 712   }
 713 };
 714
 715 class CIfrRef : public CIfrObj, public CIfrOpHeader, public CIfrQuestionHeader {
 716 private:
 717   EFI_IFR_REF *mRef;
 718
 719 public:
 720   CIfrRef () : CIfrObj (EFI_IFR_REF_OP, (CHAR8 **)&mRef),
 721               CIfrOpHeader (EFI_IFR_REF_OP, &mRef->Header),
 722               CIfrQuestionHeader (&mRef->Question) {
 723     mRef->FormId = 0;
 724   }
 725
 726   VOID SetFormId (IN EFI_FORM_ID FormId) {
 727     mRef->FormId = FormId;
 728   }
 729 };
 730
 731 class CIfrRef2 : public CIfrObj, public CIfrOpHeader, public CIfrQuestionHeader {
 732 private:
 733   EFI_IFR_REF2 *mRef2;
 734
 735 public:
 736   CIfrRef2 () : CIfrObj (EFI_IFR_REF_OP, (CHAR8 **)&mRef2, sizeof (EFI_IFR_REF2)),
 737                CIfrOpHeader (EFI_IFR_REF_OP, &mRef2->Header, sizeof (EFI_IFR_REF2)),
 738                CIfrQuestionHeader (&mRef2->Question) {
 739     mRef2->FormId     = 0;
 740     mRef2->QuestionId = EFI_QUESTION_ID_INVALID;
 741   }
 742
 743   VOID SetFormId (IN EFI_FORM_ID FormId) {
 744     mRef2->FormId = FormId;
 745   }
 746
 747   EFI_VFR_RETURN_CODE SetQuestionId (IN EFI_QUESTION_ID QuestionId) {
 748     if (QuestionId == EFI_QUESTION_ID_INVALID) {
 749       return VFR_RETURN_UNDEFINED;
 750     }
 751     mRef2->QuestionId = QuestionId;
 752     return VFR_RETURN_SUCCESS;
 753   }
 754 };
 755
 756 class CIfrRef3 : public CIfrObj, public CIfrOpHeader, public CIfrQuestionHeader {
 757 private:
 758   EFI_IFR_REF3 *mRef3;
 759
 760 public:
 761   CIfrRef3 () : CIfrObj (EFI_IFR_REF_OP, (CHAR8 **)&mRef3, sizeof(EFI_IFR_REF3)),
 762                CIfrOpHeader (EFI_IFR_REF_OP, &mRef3->Header, sizeof (EFI_IFR_REF3)),
 763                CIfrQuestionHeader (&mRef3->Question) {
 764     mRef3->FormId     = 0;
 765     mRef3->QuestionId = EFI_QUESTION_ID_INVALID;
 766     memset (&mRef3->FormSetId, 0, sizeof (EFI_GUID));
 767   }
 768
 769   VOID SetFormId (IN EFI_FORM_ID FormId) {
 770     mRef3->FormId = FormId;
 771   }
 772
 773   VOID SetQuestionId (IN EFI_QUESTION_ID QuestionId) {
 774     mRef3->QuestionId = QuestionId;
 775   }
 776
 777   VOID SetFormSetId (IN EFI_GUID FormSetId) {
 778     mRef3->FormSetId = FormSetId;
 779   }
 780 };
 781
 782 class CIfrRef4 : public CIfrObj, public CIfrOpHeader, public CIfrQuestionHeader {
 783 private:
 784   EFI_IFR_REF4 *mRef4;
 785
 786 public:
 787   CIfrRef4 () : CIfrObj (EFI_IFR_REF_OP, (CHAR8 **)&mRef4, sizeof(EFI_IFR_REF3)),
 788                CIfrOpHeader (EFI_IFR_REF_OP, &mRef4->Header, sizeof (EFI_IFR_REF3)),
 789                CIfrQuestionHeader (&mRef4->Question) {
 790     mRef4->FormId     = 0;
 791     mRef4->QuestionId = EFI_QUESTION_ID_INVALID;
 792     memset (&mRef4->FormSetId, 0, sizeof (EFI_GUID));
 793     mRef4->DevicePath = EFI_STRING_ID_INVALID;
 794   }
 795
 796   VOID SetFormId (IN EFI_FORM_ID FormId) {
 797     mRef4->FormId = FormId;
 798   }
 799
 800   VOID SetQuestionId (IN EFI_QUESTION_ID QuestionId) {
 801     mRef4->QuestionId = QuestionId;
 802   }
 803
 804   VOID SetFormSetId (IN EFI_GUID FormSetId) {
 805     mRef4->FormSetId = FormSetId;
 806   }
 807
 808   VOID SetDevicePath (IN EFI_STRING_ID DevicePath) {
 809     mRef4->DevicePath = DevicePath;
 810   }
 811 };
 812
 813 class CIfrResetButton : public CIfrObj, public CIfrOpHeader, public CIfrStatementHeader {
 814 private:
 815   EFI_IFR_RESET_BUTTON *mResetButton;
 816
 817 public:
 818   CIfrResetButton () : CIfrObj (EFI_IFR_RESET_BUTTON_OP, (CHAR8 **)&mResetButton),
 819                        CIfrOpHeader (EFI_IFR_RESET_BUTTON_OP, &mResetButton->Header),
 820                                            CIfrStatementHeader (&mResetButton->Question.Header) {
 821     mResetButton->DefaultId = EFI_HII_DEFAULT_CLASS_STANDARD;
 822   }
 823
 824   VOID SetDefaultId (IN UINT16 DefaultId) {
 825     mResetButton->DefaultId = DefaultId;
 826   }
 827 };
 828
 829 class CIfrCheckBox : public CIfrObj, public CIfrOpHeader, public CIfrQuestionHeader  {
 830 private:
 831   EFI_IFR_CHECKBOX *mCheckBox;
 832
 833 public:
 834   CIfrCheckBox () : CIfrObj (EFI_IFR_CHECKBOX_OP, (CHAR8 **)&mCheckBox),
 835                      CIfrOpHeader (EFI_IFR_CHECKBOX_OP, &mCheckBox->Header),
 836                      CIfrQuestionHeader (&mCheckBox->Question) {
 837     mCheckBox->Flags = EFI_IFR_CHECKBOX_DEFAULT;
 838     gCurrentQuestion = this;
 839   }
 840
 841   ~CIfrCheckBox () {
 842     gCurrentQuestion = NULL;
 843   }
 844
 845   EFI_VFR_RETURN_CODE SetFlags (IN UINT8 HFlags, UINT8 LFlags) {
 846     EFI_VFR_RETURN_CODE Ret;
 847
 848     Ret = CIfrQuestionHeader::SetFlags (HFlags);
 849     if (Ret != VFR_RETURN_SUCCESS) {
 850       return Ret;
 851     }
 852
 853     if (_FLAG_TEST_AND_CLEAR (LFlags, EFI_IFR_CHECKBOX_DEFAULT)) {
 854       mCheckBox->Flags |= EFI_IFR_CHECKBOX_DEFAULT;
 855     }
 856
 857     if (_FLAG_TEST_AND_CLEAR (LFlags, EFI_IFR_CHECKBOX_DEFAULT_MFG)) {
 858       mCheckBox->Flags |= EFI_IFR_CHECKBOX_DEFAULT_MFG;
 859     }
 860
 861     return _FLAGS_ZERO (LFlags) ? VFR_RETURN_SUCCESS : VFR_RETURN_FLAGS_UNSUPPORTED;
 862   }
 863 };
 864
 865 class CIfrAction : public CIfrObj, public CIfrOpHeader, public CIfrQuestionHeader {
 866 private:
 867   EFI_IFR_ACTION *mAction;
 868
 869 public:
 870   CIfrAction () : CIfrObj (EFI_IFR_ACTION_OP, (CHAR8 **)&mAction),
 871                  CIfrOpHeader (EFI_IFR_ACTION_OP, &mAction->Header),
 872                  CIfrQuestionHeader (&mAction->Question) {
 873     mAction->QuestionConfig = EFI_STRING_ID_INVALID;
 874   }
 875
 876   VOID SetQuestionConfig (IN EFI_STRING_ID QuestionConfig) {
 877     mAction->QuestionConfig = QuestionConfig;
 878   }
 879 };
 880
 881 class CIfrDate : public CIfrObj, public CIfrOpHeader, public CIfrQuestionHeader {
 882 private:
 883   EFI_IFR_DATE *mDate;
 884
 885 public:
 886   CIfrDate () : CIfrObj (EFI_IFR_DATE_OP, (CHAR8 **)&mDate),
 887                CIfrOpHeader (EFI_IFR_DATE_OP, &mDate->Header),
 888                CIfrQuestionHeader (&mDate->Question) {
 889     mDate->Flags = 0;
 890   }
 891
 892   EFI_VFR_RETURN_CODE SetFlags (IN UINT8 HFlags, IN UINT8 LFlags) {
 893     EFI_VFR_RETURN_CODE Ret;
 894
 895     Ret = CIfrQuestionHeader::SetFlags (HFlags);
 896     if (Ret != VFR_RETURN_SUCCESS) {
 897       return Ret;
 898     }
 899
 900     if (_FLAG_TEST_AND_CLEAR (LFlags, EFI_QF_DATE_YEAR_SUPPRESS)) {
 901       mDate->Flags |= EFI_QF_DATE_YEAR_SUPPRESS;
 902     }
 903
 904     if (_FLAG_TEST_AND_CLEAR (LFlags, EFI_QF_DATE_MONTH_SUPPRESS)) {
 905       mDate->Flags |= EFI_QF_DATE_MONTH_SUPPRESS;
 906     }
 907
 908     if (_FLAG_TEST_AND_CLEAR (LFlags, EFI_QF_DATE_DAY_SUPPRESS)) {
 909       mDate->Flags |= EFI_QF_DATE_DAY_SUPPRESS;
 910     }
 911
 912     if (_FLAG_TEST_AND_CLEAR (LFlags, QF_DATE_STORAGE_NORMAL)) {
 913       mDate->Flags |= QF_DATE_STORAGE_NORMAL;
 914     } else if (_FLAG_TEST_AND_CLEAR (LFlags, QF_DATE_STORAGE_TIME)) {
 915       mDate->Flags |= QF_DATE_STORAGE_TIME;
 916     } else if (_FLAG_TEST_AND_CLEAR (LFlags, QF_DATE_STORAGE_WAKEUP)) {
 917       mDate->Flags |= QF_DATE_STORAGE_WAKEUP;
 918     }
 919
 920     return _FLAGS_ZERO (LFlags) ? VFR_RETURN_SUCCESS : VFR_RETURN_FLAGS_UNSUPPORTED;
 921   }
 922 };
 923
 924 class CIfrNumeric : public CIfrObj, public CIfrOpHeader, public CIfrQuestionHeader, public CIfrMinMaxStepData {
 925 private:
 926   EFI_IFR_NUMERIC *mNumeric;
 927
 928 public:
 929   CIfrNumeric () : CIfrObj (EFI_IFR_NUMERIC_OP, (CHAR8 **)&mNumeric),
 930                    CIfrOpHeader (EFI_IFR_NUMERIC_OP, &mNumeric->Header),
 931                    CIfrQuestionHeader (&mNumeric->Question),
 932                    CIfrMinMaxStepData (&mNumeric->data) {
 933     mNumeric->Flags  = EFI_IFR_NUMERIC_SIZE_1 | EFI_IFR_DISPLAY_UINT_DEC;
 934     gCurrentQuestion = this;
 935   }
 936
 937   ~CIfrNumeric () {
 938     gCurrentQuestion = NULL;
 939   }
 940
 941   EFI_VFR_RETURN_CODE SetFlags (IN UINT8 HFlags, IN UINT8 LFlags) {
 942     EFI_VFR_RETURN_CODE Ret;
 943
 944     Ret = CIfrQuestionHeader::SetFlags (HFlags);
 945     if (Ret != VFR_RETURN_SUCCESS) {
 946       return Ret;
 947     }
 948
 949     if (LFlags & EFI_IFR_DISPLAY) {
 950       mNumeric->Flags = LFlags;
 951     } else {
 952       mNumeric->Flags = LFlags | EFI_IFR_DISPLAY_UINT_DEC;
 953     }
 954     return VFR_RETURN_SUCCESS;
 955   }
 956 };
 957
 958 class CIfrOneOf : public CIfrObj, public CIfrOpHeader, public CIfrQuestionHeader, public CIfrMinMaxStepData {
 959 private:
 960   EFI_IFR_ONE_OF *mOneOf;
 961
 962 public:
 963   CIfrOneOf () : CIfrObj (EFI_IFR_ONE_OF_OP, (CHAR8 **)&mOneOf),
 964                  CIfrOpHeader (EFI_IFR_ONE_OF_OP, &mOneOf->Header),
 965                  CIfrQuestionHeader (&mOneOf->Question),
 966                  CIfrMinMaxStepData (&mOneOf->data) {
 967     mOneOf->Flags    = 0;
 968     gCurrentQuestion = this;
 969   }
 970
 971   ~CIfrOneOf () {
 972     gCurrentQuestion = NULL;
 973   }
 974
 975   EFI_VFR_RETURN_CODE SetFlags (IN UINT8 HFlags, IN UINT8 LFlags) {
 976     EFI_VFR_RETURN_CODE Ret;
 977
 978     Ret = CIfrQuestionHeader::SetFlags (HFlags);
 979     if (Ret != VFR_RETURN_SUCCESS) {
 980       return Ret;
 981     }
 982
 983     if (LFlags & EFI_IFR_DISPLAY) {
 984       mOneOf->Flags = LFlags;
 985     } else {
 986       mOneOf->Flags = LFlags | EFI_IFR_DISPLAY_UINT_DEC;
 987     }
 988     return VFR_RETURN_SUCCESS;
 989   }
 990 };
 991
 992 class CIfrString : public CIfrObj, public CIfrOpHeader, public CIfrQuestionHeader {
 993 private:
 994   EFI_IFR_STRING *mString;
 995
 996 public:
 997   CIfrString () : CIfrObj (EFI_IFR_STRING_OP, (CHAR8 **)&mString),
 998                  CIfrOpHeader (EFI_IFR_STRING_OP, &mString->Header),
 999                  CIfrQuestionHeader (&mString->Question) {
1000     mString->Flags   = 0;
1001     mString->MinSize = 0;
1002     mString->MaxSize = 0;
1003     gCurrentQuestion = this;
1004   }
1005
1006   ~CIfrString () {
1007     gCurrentQuestion = NULL;
1008   }
1009
1010   EFI_VFR_RETURN_CODE SetFlags (IN UINT8 HFlags, IN UINT8 LFlags) {
1011     EFI_VFR_RETURN_CODE Ret;
1012
1013     Ret = CIfrQuestionHeader::SetFlags (HFlags);
1014     if (Ret != VFR_RETURN_SUCCESS) {
1015       return Ret;
1016     }
1017
1018     if (_FLAG_TEST_AND_CLEAR (LFlags, EFI_IFR_STRING_MULTI_LINE)) {
1019       mString->Flags |= EFI_IFR_STRING_MULTI_LINE;
1020     }
1021
1022     return _FLAGS_ZERO (LFlags) ? VFR_RETURN_SUCCESS : VFR_RETURN_FLAGS_UNSUPPORTED;
1023   }
1024
1025   VOID SetMinSize (IN UINT8 Flags) {
1026     mString->MinSize = Flags;
1027   }
1028
1029   VOID SetMaxSize (IN UINT8 MaxSize) {
1030     mString->MaxSize = MaxSize;
1031   }
1032 };
1033
1034 class CIfrPassword : public CIfrObj, public CIfrOpHeader, public CIfrQuestionHeader {
1035 private:
1036   EFI_IFR_PASSWORD *mPassword;
1037
1038 public:
1039   CIfrPassword () : CIfrObj (EFI_IFR_PASSWORD_OP, (CHAR8 **)&mPassword),
1040                     CIfrOpHeader (EFI_IFR_PASSWORD_OP, &mPassword->Header),
1041                     CIfrQuestionHeader (&mPassword->Question) {
1042     mPassword->MinSize = 0;
1043     mPassword->MaxSize = 0;
1044     gCurrentQuestion   = this;
1045   }
1046
1047   ~CIfrPassword () {
1048     gCurrentQuestion = NULL;
1049   }
1050
1051   VOID SetMinSize (IN UINT16 MinSize) {
1052     mPassword->MinSize = MinSize;
1053   }
1054
1055   VOID SetMaxSize (IN UINT16 MaxSize) {
1056     mPassword->MaxSize = MaxSize;
1057   }
1058 };
1059
1060 class CIfrOrderedList : public CIfrObj, public CIfrOpHeader, public CIfrQuestionHeader {
1061 private:
1062   EFI_IFR_ORDERED_LIST *mOrderedList;
1063
1064 public:
1065   CIfrOrderedList () : CIfrObj (EFI_IFR_ORDERED_LIST_OP, (CHAR8 **)&mOrderedList),
1066                       CIfrOpHeader (EFI_IFR_ORDERED_LIST_OP, &mOrderedList->Header),
1067                       CIfrQuestionHeader (&mOrderedList->Question) {
1068     mOrderedList->MaxContainers = 0;
1069     mOrderedList->Flags         = 0;
1070     gCurrentQuestion            = this;
1071   }
1072
1073   ~CIfrOrderedList () {
1074     gCurrentQuestion = NULL;
1075   }
1076
1077   VOID SetMaxContainers (IN UINT8 MaxContainers) {
1078     mOrderedList->MaxContainers = MaxContainers;
1079   }
1080
1081   EFI_VFR_RETURN_CODE SetFlags (IN UINT8 HFlags, IN UINT8 LFlags) {
1082     EFI_VFR_RETURN_CODE Ret;
1083
1084     Ret = CIfrQuestionHeader::SetFlags (HFlags);
1085     if (Ret != VFR_RETURN_SUCCESS) {
1086       return Ret;
1087     }
1088
1089     if (_FLAG_TEST_AND_CLEAR (LFlags, EFI_IFR_UNIQUE_SET)) {
1090       mOrderedList->Flags |= EFI_IFR_UNIQUE_SET;
1091     }
1092
1093     if (_FLAG_TEST_AND_CLEAR (LFlags, EFI_IFR_NO_EMPTY_SET)) {
1094       mOrderedList->Flags |= EFI_IFR_NO_EMPTY_SET;
1095     }
1096
1097     return _FLAGS_ZERO (LFlags) ? VFR_RETURN_SUCCESS : VFR_RETURN_FLAGS_UNSUPPORTED;
1098   }
1099 };
1100
1101 class CIfrTime : public CIfrObj, public CIfrOpHeader, public CIfrQuestionHeader {
1102 private:
1103   EFI_IFR_TIME *mTime;
1104
1105 public:
1106   CIfrTime () : CIfrObj (EFI_IFR_TIME_OP, (CHAR8 **)&mTime),
1107                 CIfrOpHeader (EFI_IFR_TIME_OP, &mTime->Header),
1108                 CIfrQuestionHeader (&mTime->Question) {
1109     mTime->Flags = 0;
1110   }
1111
1112   EFI_VFR_RETURN_CODE SetFlags (IN UINT8 HFlags, IN UINT8 LFlags) {
1113     EFI_VFR_RETURN_CODE Ret;
1114
1115     Ret = CIfrQuestionHeader::SetFlags (HFlags);
1116     if (Ret != VFR_RETURN_SUCCESS) {
1117       return Ret;
1118     }
1119
1120     if (_FLAG_TEST_AND_CLEAR (LFlags, QF_TIME_HOUR_SUPPRESS)) {
1121       mTime->Flags |= QF_TIME_HOUR_SUPPRESS;
1122     }
1123
1124     if (_FLAG_TEST_AND_CLEAR (LFlags, QF_TIME_MINUTE_SUPPRESS)) {
1125       mTime->Flags |= QF_TIME_MINUTE_SUPPRESS;
1126     }
1127
1128     if (_FLAG_TEST_AND_CLEAR (LFlags, QF_TIME_SECOND_SUPPRESS)) {
1129       mTime->Flags |= QF_TIME_SECOND_SUPPRESS;
1130     }
1131
1132     if (_FLAG_TEST_AND_CLEAR (LFlags, QF_TIME_STORAGE_NORMAL)) {
1133       mTime->Flags |= QF_TIME_STORAGE_NORMAL;
1134     } else if (_FLAG_TEST_AND_CLEAR (LFlags, QF_TIME_STORAGE_TIME)) {
1135       mTime->Flags |= QF_TIME_STORAGE_TIME;
1136     } else if (_FLAG_TEST_AND_CLEAR (LFlags, QF_TIME_STORAGE_WAKEUP)) {
1137       mTime->Flags |= QF_TIME_STORAGE_WAKEUP;
1138     }
1139
1140     return _FLAGS_ZERO (LFlags) ? VFR_RETURN_SUCCESS : VFR_RETURN_FLAGS_UNSUPPORTED;
1141   }
1142 };
1143
1144 class CIfrDisableIf : public CIfrObj, public CIfrOpHeader {
1145 private:
1146   EFI_IFR_DISABLE_IF *mDisableIf;
1147
1148 public:
1149   CIfrDisableIf () : CIfrObj (EFI_IFR_DISABLE_IF_OP, (CHAR8 **)&mDisableIf),
1150                    mDisableIf ((EFI_IFR_DISABLE_IF *) GetObjBinAddr()),
1151                    CIfrOpHeader (EFI_IFR_DISABLE_IF_OP, &mDisableIf->Header) {}
1152 };
1153
1154 class CIfrSuppressIf : public CIfrObj, public CIfrOpHeader {
1155 private:
1156   EFI_IFR_SUPPRESS_IF *mSuppressIf;
1157
1158 public:
1159   CIfrSuppressIf () : CIfrObj (EFI_IFR_SUPPRESS_IF_OP, (CHAR8 **)&mSuppressIf),
1160                      CIfrOpHeader (EFI_IFR_SUPPRESS_IF_OP, &mSuppressIf->Header) {}
1161 };
1162
1163 class CIfrGrayOutIf : public CIfrObj, public CIfrOpHeader {
1164 private:
1165   EFI_IFR_GRAY_OUT_IF *mGrayOutIf;
1166
1167 public:
1168   CIfrGrayOutIf () : CIfrObj (EFI_IFR_GRAY_OUT_IF_OP, (CHAR8 **)&mGrayOutIf),
1169                     CIfrOpHeader (EFI_IFR_GRAY_OUT_IF_OP, &mGrayOutIf->Header) {}
1170 };
1171
1172 class CIfrInconsistentIf : public CIfrObj, public CIfrOpHeader {
1173 private:
1174   EFI_IFR_INCONSISTENT_IF *mInconsistentIf;
1175
1176 public:
1177   CIfrInconsistentIf () : CIfrObj (EFI_IFR_INCONSISTENT_IF_OP, (CHAR8 **)&mInconsistentIf),
1178                         CIfrOpHeader (EFI_IFR_INCONSISTENT_IF_OP, &mInconsistentIf->Header) {
1179     mInconsistentIf->Error = EFI_STRING_ID_INVALID;
1180   }
1181
1182   VOID SetError (IN EFI_STRING_ID Error) {
1183     mInconsistentIf->Error = Error;
1184   }
1185 };
1186
1187 class CIfrNoSubmitIf : public CIfrObj, public CIfrOpHeader {
1188 private:
1189   EFI_IFR_NO_SUBMIT_IF *mNoSubmitIf;
1190
1191 public:
1192   CIfrNoSubmitIf () : CIfrObj (EFI_IFR_NO_SUBMIT_IF_OP, (CHAR8 **)&mNoSubmitIf),
1193                      CIfrOpHeader (EFI_IFR_NO_SUBMIT_IF_OP, &mNoSubmitIf->Header) {
1194     mNoSubmitIf->Error = EFI_STRING_ID_INVALID;
1195   }
1196
1197   VOID SetError (IN EFI_STRING_ID Error) {
1198     mNoSubmitIf->Error = Error;
1199   }
1200 };
1201
1202 class CIfrRefresh : public CIfrObj, public CIfrOpHeader {
1203 private:
1204   EFI_IFR_REFRESH *mRefresh;
1205
1206 public:
1207   CIfrRefresh () : CIfrObj (EFI_IFR_REFRESH_OP, (CHAR8 **)&mRefresh),
1208                   CIfrOpHeader (EFI_IFR_REFRESH_OP, &mRefresh->Header) {
1209     mRefresh->RefreshInterval = 0;
1210   }
1211
1212   VOID SetRefreshInterval (IN UINT8 RefreshInterval) {
1213     mRefresh->RefreshInterval = RefreshInterval;
1214   }
1215 };
1216
1217 class CIfrVarStoreDevice : public CIfrObj, public CIfrOpHeader {
1218 private:
1219   EFI_IFR_VARSTORE_DEVICE *mVarStoreDevice;
1220
1221 public:
1222   CIfrVarStoreDevice () : CIfrObj (EFI_IFR_VARSTORE_DEVICE_OP, (CHAR8 **)&mVarStoreDevice),
1223                           CIfrOpHeader (EFI_IFR_VARSTORE_DEVICE_OP, &mVarStoreDevice->Header) {
1224     mVarStoreDevice->DevicePath = EFI_STRING_ID_INVALID;
1225   }
1226
1227   VOID SetDevicePath (IN EFI_STRING_ID DevicePath) {
1228     mVarStoreDevice->DevicePath = DevicePath;
1229   }
1230 };
1231
1232 class CIfrOneOfOption : public CIfrObj, public CIfrOpHeader {
1233 private:
1234   EFI_IFR_ONE_OF_OPTION *mOneOfOption;
1235
1236 public:
1237   CIfrOneOfOption () : CIfrObj (EFI_IFR_ONE_OF_OPTION_OP, (CHAR8 **)&mOneOfOption),
1238                        CIfrOpHeader (EFI_IFR_ONE_OF_OPTION_OP, &mOneOfOption->Header) {
1239     mOneOfOption->Flags  = 0;
1240     mOneOfOption->Option = EFI_STRING_ID_INVALID;
1241     mOneOfOption->Type   = EFI_IFR_TYPE_OTHER;
1242     memset (&mOneOfOption->Value, 0, sizeof (mOneOfOption->Value));
1243   }
1244
1245   VOID SetOption (IN EFI_STRING_ID Option) {
1246     mOneOfOption->Option = Option;
1247   }
1248
1249   EFI_VFR_RETURN_CODE SetFlags (IN UINT8 LFlags) {
1250     if (_FLAG_TEST_AND_CLEAR (LFlags, EFI_IFR_OPTION_DEFAULT)) {
1251       mOneOfOption->Flags |= EFI_IFR_OPTION_DEFAULT;
1252     }
1253
1254     if (_FLAG_TEST_AND_CLEAR (LFlags, EFI_IFR_OPTION_DEFAULT_MFG)) {
1255       mOneOfOption->Flags |= EFI_IFR_OPTION_DEFAULT_MFG;
1256     }
1257
1258     if (_IS_EQUAL (LFlags, EFI_IFR_TYPE_NUM_SIZE_8)) {
1259       _FLAG_CLEAR (LFlags, EFI_IFR_TYPE_NUM_SIZE_8);
1260       mOneOfOption->Flags |= EFI_IFR_TYPE_NUM_SIZE_8;
1261     } else if (_IS_EQUAL (LFlags, EFI_IFR_TYPE_NUM_SIZE_16)) {
1262       _FLAG_CLEAR (LFlags, EFI_IFR_TYPE_NUM_SIZE_16);
1263       mOneOfOption->Flags |= EFI_IFR_TYPE_NUM_SIZE_16;
1264     } else if (_IS_EQUAL (LFlags, EFI_IFR_TYPE_NUM_SIZE_32)) {
1265       _FLAG_CLEAR (LFlags, EFI_IFR_TYPE_NUM_SIZE_32);
1266       mOneOfOption->Flags |= EFI_IFR_TYPE_NUM_SIZE_32;
1267     } else if (_IS_EQUAL (LFlags, EFI_IFR_TYPE_NUM_SIZE_64)) {
1268       _FLAG_CLEAR (LFlags, EFI_IFR_TYPE_NUM_SIZE_64);
1269       mOneOfOption->Flags |= EFI_IFR_TYPE_NUM_SIZE_64;
1270     } else if (_IS_EQUAL (LFlags, EFI_IFR_TYPE_BOOLEAN)) {
1271       _FLAG_CLEAR (LFlags, EFI_IFR_TYPE_BOOLEAN);
1272       mOneOfOption->Flags |= EFI_IFR_TYPE_BOOLEAN;
1273     } else if (_IS_EQUAL (LFlags, EFI_IFR_TYPE_TIME)) {
1274       _FLAG_CLEAR (LFlags, EFI_IFR_TYPE_TIME);
1275       mOneOfOption->Flags |= EFI_IFR_TYPE_TIME;
1276     } else if (_IS_EQUAL (LFlags, EFI_IFR_TYPE_DATE)) {
1277       _FLAG_CLEAR (LFlags, EFI_IFR_TYPE_DATE);
1278       mOneOfOption->Flags |= EFI_IFR_TYPE_DATE;
1279     } else if (_IS_EQUAL (LFlags, EFI_IFR_TYPE_STRING)) {
1280       _FLAG_CLEAR (LFlags, EFI_IFR_TYPE_STRING);
1281       mOneOfOption->Flags |= EFI_IFR_TYPE_STRING;
1282     } else if (_IS_EQUAL (LFlags, EFI_IFR_TYPE_OTHER)) {
1283       _FLAG_CLEAR (LFlags, EFI_IFR_TYPE_OTHER);
1284       mOneOfOption->Flags |= EFI_IFR_TYPE_OTHER;
1285     }
1286
1287     return _FLAGS_ZERO (LFlags) ? VFR_RETURN_SUCCESS : VFR_RETURN_FLAGS_UNSUPPORTED;
1288   }
1289
1290   VOID SetType (IN UINT8 Type) {
1291     mOneOfOption->Type = Type;
1292   }
1293
1294   VOID SetValue (IN EFI_IFR_TYPE_VALUE Value) {
1295     mOneOfOption->Value = Value;
1296   }
1297
1298   UINT8 GetFlags (VOID) {
1299     return mOneOfOption->Flags;
1300   }
1301 };
1302
1303 static EFI_GUID IfrTianoGuid = EFI_IFR_TIANO_GUID;
1304
1305 class CIfrClass : public CIfrObj, public CIfrOpHeader {
1306 private:
1307   EFI_IFR_GUID_CLASS *mClass;
1308
1309 public:
1310   CIfrClass () : CIfrObj (EFI_IFR_GUID_OP, (CHAR8 **)&mClass, sizeof (EFI_IFR_GUID_CLASS)),
1311                 CIfrOpHeader (EFI_IFR_GUID_OP, &mClass->Header, sizeof (EFI_IFR_GUID_CLASS)) {
1312     mClass->ExtendOpCode = EFI_IFR_EXTEND_OP_CLASS;
1313     mClass->Guid         = IfrTianoGuid;
1314     mClass->Class        = EFI_NON_DEVICE_CLASS;
1315   }
1316
1317   VOID SetClass (IN UINT16 Class) {
1318     mClass->Class        = Class;
1319   }
1320 };
1321
1322 class CIfrSubClass : public CIfrObj, public CIfrOpHeader {
1323 private:
1324   EFI_IFR_GUID_SUBCLASS *mSubClass;
1325
1326 public:
1327   CIfrSubClass () : CIfrObj (EFI_IFR_GUID_OP, (CHAR8 **)&mSubClass, sizeof (EFI_IFR_GUID_SUBCLASS)),
1328                     CIfrOpHeader (EFI_IFR_GUID_OP, &mSubClass->Header, sizeof (EFI_IFR_GUID_SUBCLASS)) {
1329     mSubClass->ExtendOpCode = EFI_IFR_EXTEND_OP_SUBCLASS;
1330     mSubClass->Guid         = IfrTianoGuid;
1331     mSubClass->SubClass     = EFI_SETUP_APPLICATION_SUBCLASS;
1332   }
1333
1334   VOID SetSubClass (IN UINT16 SubClass) {
1335     mSubClass->SubClass = SubClass;
1336   }
1337 };
1338
1339 class CIfrLabel : public CIfrObj, public CIfrOpHeader {
1340 private:
1341   EFI_IFR_GUID_LABEL *mLabel;
1342
1343 public:
1344   CIfrLabel () : CIfrObj (EFI_IFR_GUID_OP, (CHAR8 **)&mLabel, sizeof (EFI_IFR_GUID_LABEL)),
1345                 CIfrOpHeader (EFI_IFR_GUID_OP, &mLabel->Header, sizeof (EFI_IFR_GUID_LABEL)) {
1346     mLabel->ExtendOpCode = EFI_IFR_EXTEND_OP_LABEL;
1347     mLabel->Guid         = IfrTianoGuid;
1348   }
1349
1350   VOID SetNumber (IN UINT16 Number) {
1351     mLabel->Number = Number;
1352   }
1353 };
1354
1355 class CIfrBanner : public CIfrObj, public CIfrOpHeader {
1356 private:
1357   EFI_IFR_GUID_BANNER *mBanner;
1358
1359 public:
1360   CIfrBanner () : CIfrObj (EFI_IFR_GUID_OP, (CHAR8 **)&mBanner, sizeof (EFI_IFR_GUID_BANNER)),
1361                   CIfrOpHeader (EFI_IFR_GUID_OP, &mBanner->Header, sizeof (EFI_IFR_GUID_BANNER)) {
1362     mBanner->ExtendOpCode = EFI_IFR_EXTEND_OP_BANNER;
1363     mBanner->Guid         = IfrTianoGuid;
1364   }
1365
1366   VOID SetTitle (IN EFI_STRING_ID StringId) {
1367     mBanner->Title = StringId;
1368   }
1369
1370   VOID SetLine (IN UINT16 Line) {
1371     mBanner->LineNumber = Line;
1372   }
1373
1374   VOID SetAlign (IN UINT8 Align) {
1375     mBanner->Alignment = Align;
1376   }
1377 };
1378
1379 class CIfrTimeout : public CIfrObj, public CIfrOpHeader {
1380 private:
1381   EFI_IFR_GUID_TIMEOUT *mTimeout;
1382
1383 public:
1384   CIfrTimeout (IN UINT16 Timeout = 0) : CIfrObj (EFI_IFR_GUID_OP, (CHAR8 **)&mTimeout, sizeof (EFI_IFR_GUID_TIMEOUT)),
1385                                         CIfrOpHeader (EFI_IFR_GUID_OP, &mTimeout->Header, sizeof (EFI_IFR_GUID_TIMEOUT)) {
1386     mTimeout->ExtendOpCode = EFI_IFR_EXTEND_OP_TIMEOUT;
1387     mTimeout->Guid         = IfrTianoGuid;
1388     mTimeout->TimeOut      = Timeout;
1389   }
1390
1391   VOID SetTimeout (IN UINT16 Timeout) {
1392     mTimeout->TimeOut = Timeout;
1393   }
1394 };
1395
1396 class CIfrDup : public CIfrObj, public CIfrOpHeader {
1397 private:
1398   EFI_IFR_DUP *mDup;
1399
1400 public:
1401   CIfrDup (
1402   IN UINT32 LineNo
1403   ) : CIfrObj (EFI_IFR_DUP_OP, (CHAR8 **)&mDup),
1404       CIfrOpHeader (EFI_IFR_DUP_OP, &mDup->Header) {
1405     SetLineNo (LineNo);
1406   }
1407 };
1408
1409 class CIfrEqIdId : public CIfrObj, public CIfrOpHeader {
1410 private:
1411   EFI_IFR_EQ_ID_ID   *mEqIdId;
1412
1413 public:
1414   CIfrEqIdId (
1415   IN UINT32 LineNo
1416   ) : CIfrObj (EFI_IFR_EQ_ID_ID_OP, (CHAR8 **)&mEqIdId),
1417                  CIfrOpHeader (EFI_IFR_EQ_ID_ID_OP, &mEqIdId->Header) {
1418     SetLineNo (LineNo);
1419     mEqIdId->QuestionId1 = EFI_QUESTION_ID_INVALID;
1420     mEqIdId->QuestionId2 = EFI_QUESTION_ID_INVALID;
1421   }
1422
1423   VOID SetQuestionId1 (
1424   IN EFI_QUESTION_ID QuestionId,
1425   IN INT8            *VarIdStr,
1426   IN UINT32          LineNo
1427   ) {
1428     if (QuestionId != EFI_QUESTION_ID_INVALID) {
1429       mEqIdId->QuestionId1 = QuestionId;
1430     } else {
1431       gCFormPkg.AssignPending (VarIdStr, (VOID *)(&mEqIdId->QuestionId1), sizeof (EFI_QUESTION_ID), LineNo);
1432     }
1433   }
1434
1435   VOID SetQuestionId2 (
1436   IN EFI_QUESTION_ID QuestionId,
1437   IN INT8            *VarIdStr,
1438   IN UINT32          LineNo
1439   ) {
1440     if (QuestionId != EFI_QUESTION_ID_INVALID) {
1441       mEqIdId->QuestionId2 = QuestionId;
1442     } else {
1443       gCFormPkg.AssignPending (VarIdStr, (VOID *)(&mEqIdId->QuestionId2), sizeof (EFI_QUESTION_ID), LineNo);
1444     }
1445   }
1446 };
1447
1448 class CIfrEqIdVal : public CIfrObj, public CIfrOpHeader {
1449 private:
1450   EFI_IFR_EQ_ID_VAL *mEqIdVal;
1451
1452 public:
1453   CIfrEqIdVal (
1454   IN UINT32 LineNo
1455   ) : CIfrObj (EFI_IFR_EQ_ID_VAL_OP, (CHAR8 **)&mEqIdVal),
1456       CIfrOpHeader (EFI_IFR_EQ_ID_VAL_OP, &mEqIdVal->Header) {
1457     SetLineNo (LineNo);
1458     mEqIdVal->QuestionId = EFI_QUESTION_ID_INVALID;
1459   }
1460
1461   VOID SetQuestionId (
1462   IN EFI_QUESTION_ID QuestionId,
1463   IN INT8            *VarIdStr,
1464   IN UINT32          LineNo
1465   ) {
1466     if (QuestionId != EFI_QUESTION_ID_INVALID) {
1467       mEqIdVal->QuestionId = QuestionId;
1468     } else {
1469       gCFormPkg.AssignPending (VarIdStr, (VOID *)(&mEqIdVal->QuestionId), sizeof (EFI_QUESTION_ID), LineNo);
1470     }
1471   }
1472
1473   VOID SetValue (IN UINT16 Value) {
1474     mEqIdVal->Value = Value;
1475   }
1476 };
1477
1478 class CIfrEqIdList : public CIfrObj, public CIfrOpHeader {
1479 private:
1480   EFI_IFR_EQ_ID_LIST *mEqIdVList;
1481
1482 public:
1483   CIfrEqIdList (
1484   IN UINT32 LineNo
1485   ) : CIfrObj (EFI_IFR_EQ_ID_LIST_OP, (CHAR8 **)&mEqIdVList, sizeof (EFI_IFR_EQ_ID_LIST), TRUE),
1486                    CIfrOpHeader (EFI_IFR_EQ_ID_LIST_OP, &mEqIdVList->Header) {
1487     SetLineNo (LineNo);
1488     mEqIdVList->QuestionId   = EFI_QUESTION_ID_INVALID;
1489     mEqIdVList->ListLength   = 0;
1490     mEqIdVList->ValueList[0] = 0;
1491   }
1492
1493   VOID SetQuestionId (
1494   IN EFI_QUESTION_ID QuestionId,
1495   IN INT8            *VarIdStr,
1496   IN UINT32          LineNo
1497   ) {
1498     if (QuestionId != EFI_QUESTION_ID_INVALID) {
1499       mEqIdVList->QuestionId = QuestionId;
1500     } else {
1501       gCFormPkg.AssignPending (VarIdStr, (VOID *)(&mEqIdVList->QuestionId), sizeof (EFI_QUESTION_ID), LineNo);
1502     }
1503   }
1504
1505   VOID SetListLength (IN UINT16 ListLength) {
1506     mEqIdVList->ListLength = ListLength;
1507   }
1508
1509   VOID SetValueList (IN UINT16 Index, IN UINT16 Value) {
1510     if (Index == 0) {
1511       mEqIdVList->ValueList[0] = Value;
1512       return;
1513     }
1514
1515     if (ExpendObjBin (sizeof (UINT16)) ==TRUE) {
1516       IncLength (sizeof (UINT16));
1517       mEqIdVList->ValueList[Index] = Value;
1518     }
1519   }
1520 };
1521
1522 class CIfrQuestionRef1 : public CIfrObj, public CIfrOpHeader {
1523 private:
1524   EFI_IFR_QUESTION_REF1 *mQuestionRef1;
1525
1526 public:
1527   CIfrQuestionRef1 (
1528   IN UINT32 LineNo
1529   ) : CIfrObj (EFI_IFR_QUESTION_REF1_OP, (CHAR8 **)&mQuestionRef1),
1530       CIfrOpHeader (EFI_IFR_QUESTION_REF1_OP, &mQuestionRef1->Header) {
1531     SetLineNo (LineNo);
1532     mQuestionRef1->QuestionId = EFI_QUESTION_ID_INVALID;
1533   }
1534
1535   VOID SetQuestionId (
1536   IN EFI_QUESTION_ID QuestionId,
1537   IN INT8            *VarIdStr,
1538   IN UINT32          LineNo
1539   ) {
1540     if (QuestionId != EFI_QUESTION_ID_INVALID) {
1541       mQuestionRef1->QuestionId = QuestionId;
1542     } else {
1543       gCFormPkg.AssignPending (VarIdStr, (VOID *)(&mQuestionRef1->QuestionId), sizeof (EFI_QUESTION_ID), LineNo);
1544     }
1545   }
1546 };
1547
1548 class CIfrQuestionRef2 : public CIfrObj, public CIfrOpHeader {
1549 private:
1550   EFI_IFR_QUESTION_REF2 *mQuestionRef2;
1551
1552 public:
1553   CIfrQuestionRef2 (
1554   IN UINT32 LineNo
1555   ) : CIfrObj (EFI_IFR_QUESTION_REF2_OP, (CHAR8 **)&mQuestionRef2),
1556       CIfrOpHeader (EFI_IFR_QUESTION_REF2_OP, &mQuestionRef2->Header) {
1557     SetLineNo (LineNo);
1558   }
1559 };
1560
1561 class CIfrQuestionRef3 : public CIfrObj, public CIfrOpHeader {
1562 private:
1563   EFI_IFR_QUESTION_REF3 *mQuestionRef3;
1564
1565 public:
1566   CIfrQuestionRef3 (
1567   IN UINT32 LineNo
1568   ) : CIfrObj (EFI_IFR_QUESTION_REF3_OP, (CHAR8 **)&mQuestionRef3),
1569       CIfrOpHeader (EFI_IFR_QUESTION_REF3_OP, &mQuestionRef3->Header) {
1570     SetLineNo (LineNo);
1571   }
1572 };
1573
1574 class CIfrQuestionRef3_2 : public CIfrObj, public CIfrOpHeader {
1575 private:
1576   EFI_IFR_QUESTION_REF3_2 *mQuestionRef3_2;
1577
1578 public:
1579   CIfrQuestionRef3_2 (
1580   IN UINT32 LineNo
1581   ) : CIfrObj (EFI_IFR_QUESTION_REF3_OP, (CHAR8 **)&mQuestionRef3_2, sizeof (EFI_IFR_QUESTION_REF3_2)),
1582       CIfrOpHeader (EFI_IFR_QUESTION_REF3_OP, &mQuestionRef3_2->Header, sizeof (EFI_IFR_QUESTION_REF3_2)) {
1583     SetLineNo (LineNo);
1584     mQuestionRef3_2->DevicePath = EFI_STRING_ID_INVALID;
1585   }
1586
1587   VOID SetDevicePath (IN EFI_STRING_ID DevicePath) {
1588     mQuestionRef3_2->DevicePath = DevicePath;
1589   }
1590 };
1591
1592 class CIfrQuestionRef3_3 : public CIfrObj, public CIfrOpHeader {
1593 private:
1594   EFI_IFR_QUESTION_REF3_3 *mQuestionRef3_3;
1595
1596 public:
1597   CIfrQuestionRef3_3 (
1598   IN UINT32 LineNo
1599   ) : CIfrObj (EFI_IFR_QUESTION_REF3_OP, (CHAR8 **)&mQuestionRef3_3, sizeof (EFI_IFR_QUESTION_REF3_3)),
1600       CIfrOpHeader (EFI_IFR_QUESTION_REF3_OP, &mQuestionRef3_3->Header, sizeof (EFI_IFR_QUESTION_REF3_3)) {
1601     SetLineNo (LineNo);
1602     mQuestionRef3_3->DevicePath = EFI_STRING_ID_INVALID;
1603     memset (&mQuestionRef3_3->Guid, 0, sizeof (EFI_GUID));
1604   }
1605
1606   VOID SetDevicePath (IN EFI_STRING_ID DevicePath) {
1607     mQuestionRef3_3->DevicePath = DevicePath;
1608   }
1609
1610   VOID SetGuid (IN EFI_GUID *Guid) {
1611     mQuestionRef3_3->Guid = *Guid;
1612   }
1613 };
1614
1615 class CIfrRuleRef : public CIfrObj, public CIfrOpHeader {
1616 private:
1617   EFI_IFR_RULE_REF *mRuleRef;
1618
1619 public:
1620   CIfrRuleRef (
1621   IN UINT32 LineNo
1622   ) : CIfrObj (EFI_IFR_RULE_REF_OP, (CHAR8 **)&mRuleRef),
1623       CIfrOpHeader (EFI_IFR_RULE_REF_OP, &mRuleRef->Header) {
1624     SetLineNo (LineNo);
1625     mRuleRef->RuleId = EFI_RULE_ID_INVALID;
1626   }
1627
1628   VOID SetRuleId (IN UINT8 RuleId) {
1629     mRuleRef->RuleId = RuleId;
1630   }
1631 };
1632
1633 class CIfrStringRef1 : public CIfrObj, public CIfrOpHeader {
1634 private:
1635   EFI_IFR_STRING_REF1 *mStringRef1;
1636
1637 public:
1638   CIfrStringRef1 (
1639   IN UINT32 LineNo
1640   ) : CIfrObj (EFI_IFR_STRING_REF1_OP, (CHAR8 **)&mStringRef1),
1641       CIfrOpHeader (EFI_IFR_STRING_REF1_OP, &mStringRef1->Header) {
1642     SetLineNo (LineNo);
1643     mStringRef1->StringId = EFI_STRING_ID_INVALID;
1644   }
1645
1646   VOID SetStringId (IN EFI_STRING_ID StringId) {
1647     mStringRef1->StringId = StringId;
1648   }
1649 };
1650
1651 class CIfrStringRef2 : public CIfrObj, public CIfrOpHeader {
1652 private:
1653   EFI_IFR_STRING_REF2 *mStringRef2;
1654
1655 public:
1656   CIfrStringRef2 (
1657   IN UINT32 LineNo
1658   ) : CIfrObj (EFI_IFR_STRING_REF2_OP, (CHAR8 **)&mStringRef2),
1659       CIfrOpHeader (EFI_IFR_STRING_REF2_OP, &mStringRef2->Header) {
1660     SetLineNo (LineNo);
1661   }
1662 };
1663
1664 class CIfrThis : public CIfrObj, public CIfrOpHeader {
1665 private:
1666   EFI_IFR_THIS *mThis;
1667
1668 public:
1669   CIfrThis (
1670   IN UINT32 LineNo
1671   ) : CIfrObj (EFI_IFR_THIS_OP, (CHAR8 **)&mThis),
1672       CIfrOpHeader (EFI_IFR_THIS_OP, &mThis->Header) {
1673     SetLineNo (LineNo);
1674   }
1675 };
1676
1677 class CIfrUint8 : public CIfrObj, public CIfrOpHeader {
1678 private:
1679   EFI_IFR_UINT8 *mUint8;
1680
1681 public:
1682   CIfrUint8 (
1683   IN UINT32 LineNo
1684   ) : CIfrObj (EFI_IFR_UINT8_OP, (CHAR8 **)&mUint8),
1685       CIfrOpHeader (EFI_IFR_UINT8_OP, &mUint8->Header) {
1686     SetLineNo (LineNo);
1687   }
1688
1689   VOID SetValue (IN UINT8 Value) {
1690     mUint8->Value = Value;
1691   }
1692 };
1693
1694 class CIfrUint16 : public CIfrObj, public CIfrOpHeader {
1695 private:
1696   EFI_IFR_UINT16 *mUint16;
1697
1698 public:
1699   CIfrUint16 (
1700   IN UINT32 LineNo
1701   ) : CIfrObj (EFI_IFR_UINT16_OP, (CHAR8 **)&mUint16),
1702       CIfrOpHeader (EFI_IFR_UINT16_OP, &mUint16->Header) {
1703     SetLineNo (LineNo);
1704   }
1705
1706   VOID SetValue (IN UINT16 Value) {
1707     mUint16->Value = Value;
1708   }
1709 };
1710
1711 class CIfrUint32 : public CIfrObj, public CIfrOpHeader {
1712 private:
1713   EFI_IFR_UINT32 *mUint32;
1714
1715 public:
1716   CIfrUint32 (
1717   IN UINT32 LineNo
1718   ) : CIfrObj (EFI_IFR_UINT32_OP, (CHAR8 **)&mUint32),
1719       CIfrOpHeader (EFI_IFR_UINT32_OP, &mUint32->Header) {
1720     SetLineNo (LineNo);
1721   }
1722
1723   VOID SetValue (IN UINT32 Value) {
1724     mUint32->Value = Value;
1725   }
1726 };
1727
1728 class CIfrUint64 : public CIfrObj, public CIfrOpHeader {
1729 private:
1730   EFI_IFR_UINT64 *mUint64;
1731
1732 public:
1733   CIfrUint64 (
1734   IN UINT32 LineNo
1735   ) : CIfrObj (EFI_IFR_UINT64_OP, (CHAR8 **)&mUint64),
1736       CIfrOpHeader (EFI_IFR_UINT64_OP, &mUint64->Header) {
1737     SetLineNo (LineNo);
1738   }
1739
1740   VOID SetValue (IN UINT64 Value) {
1741     mUint64->Value = Value;
1742   }
1743 };
1744
1745 class CIfrTrue : public CIfrObj, public CIfrOpHeader {
1746 private:
1747   EFI_IFR_TRUE *mTrue;
1748
1749 public:
1750   CIfrTrue (
1751   IN UINT32 LineNo
1752   ) : CIfrObj (EFI_IFR_TRUE_OP, (CHAR8 **)&mTrue),
1753       CIfrOpHeader (EFI_IFR_TRUE_OP, &mTrue->Header) {
1754     SetLineNo (LineNo);
1755   }
1756 };
1757
1758 class CIfrFalse : public CIfrObj, public CIfrOpHeader {
1759 private:
1760   EFI_IFR_FALSE *mFalse;
1761
1762 public:
1763   CIfrFalse (
1764   IN UINT32 LineNo
1765   ) : CIfrObj (EFI_IFR_FALSE_OP, (CHAR8 **)&mFalse),
1766       CIfrOpHeader (EFI_IFR_FALSE_OP, &mFalse->Header) {
1767     SetLineNo (LineNo);
1768   }
1769 };
1770
1771 class CIfrOne : public CIfrObj, public CIfrOpHeader {
1772 private:
1773   EFI_IFR_ONE *mOne;
1774
1775 public:
1776   CIfrOne (
1777   IN UINT32 LineNo
1778   ) : CIfrObj (EFI_IFR_ONE_OP, (CHAR8 **)&mOne),
1779       CIfrOpHeader (EFI_IFR_ONE_OP, &mOne->Header) {
1780     SetLineNo (LineNo);
1781   }
1782 };
1783
1784 class CIfrOnes : public CIfrObj, public CIfrOpHeader {
1785 private:
1786   EFI_IFR_ONES *mOnes;
1787
1788 public:
1789   CIfrOnes (
1790   IN UINT32 LineNo
1791   ) : CIfrObj (EFI_IFR_ONES_OP, (CHAR8 **)&mOnes),
1792       CIfrOpHeader (EFI_IFR_ONES_OP, &mOnes->Header) {
1793     SetLineNo (LineNo);
1794   }
1795 };
1796
1797 class CIfrZero : public CIfrObj, public CIfrOpHeader {
1798 private:
1799   EFI_IFR_ZERO *mZero;
1800
1801 public:
1802   CIfrZero (
1803   IN UINT32 LineNo
1804   ) : CIfrObj (EFI_IFR_ZERO_OP, (CHAR8 **)&mZero),
1805       CIfrOpHeader (EFI_IFR_ZERO_OP, &mZero->Header) {
1806     SetLineNo (LineNo);
1807   }
1808 };
1809
1810 class CIfrUndefined : public CIfrObj, public CIfrOpHeader {
1811 private:
1812   EFI_IFR_UNDEFINED *mUndefined;
1813
1814 public:
1815   CIfrUndefined (
1816   IN UINT32 LineNo
1817   ) : CIfrObj (EFI_IFR_UNDEFINED_OP, (CHAR8 **)&mUndefined),
1818       CIfrOpHeader (EFI_IFR_UNDEFINED_OP, &mUndefined->Header) {
1819     SetLineNo (LineNo);
1820   }
1821 };
1822
1823 class CIfrVersion : public CIfrObj, public CIfrOpHeader {
1824 private:
1825   EFI_IFR_VERSION *mVersion;
1826
1827 public:
1828   CIfrVersion (
1829   IN UINT32 LineNo
1830   ) : CIfrObj (EFI_IFR_VERSION_OP, (CHAR8 **)&mVersion),
1831       CIfrOpHeader (EFI_IFR_VERSION_OP, &mVersion->Header) {
1832     SetLineNo (LineNo);
1833   }
1834 };
1835
1836 class CIfrLength : public CIfrObj, public CIfrOpHeader {
1837 private:
1838   EFI_IFR_LENGTH *mLength;
1839
1840 public:
1841   CIfrLength (
1842   IN UINT32 LineNo
1843   ) : CIfrObj (EFI_IFR_LENGTH_OP, (CHAR8 **)&mLength),
1844       CIfrOpHeader (EFI_IFR_LENGTH_OP, &mLength->Header) {
1845     SetLineNo (LineNo);
1846   }
1847 };
1848
1849 class CIfrNot : public CIfrObj, public CIfrOpHeader {
1850 private:
1851   EFI_IFR_NOT *mNot;
1852
1853 public:
1854   CIfrNot (
1855   IN UINT32 LineNo
1856   ) : CIfrObj (EFI_IFR_NOT_OP, (CHAR8 **)&mNot),
1857       CIfrOpHeader (EFI_IFR_NOT_OP, &mNot->Header) {
1858     SetLineNo (LineNo);
1859   }
1860 };
1861
1862 class CIfrBitWiseNot : public CIfrObj, public CIfrOpHeader {
1863 private:
1864   EFI_IFR_BITWISE_NOT *mBitWise;
1865
1866 public:
1867   CIfrBitWiseNot (
1868   IN UINT32 LineNo
1869   ) : CIfrObj (EFI_IFR_BITWISE_NOT_OP, (CHAR8 **)&mBitWise),
1870       CIfrOpHeader (EFI_IFR_BITWISE_NOT_OP, &mBitWise->Header) {
1871     SetLineNo (LineNo);
1872   }
1873 };
1874
1875 class CIfrToBoolean : public CIfrObj, public CIfrOpHeader {
1876 private:
1877   EFI_IFR_TO_BOOLEAN *mToBoolean;
1878
1879 public:
1880   CIfrToBoolean (
1881   IN UINT32 LineNo
1882   ) : CIfrObj (EFI_IFR_TO_BOOLEAN_OP, (CHAR8 **)&mToBoolean),
1883       CIfrOpHeader (EFI_IFR_TO_BOOLEAN_OP, &mToBoolean->Header) {
1884     SetLineNo (LineNo);
1885   }
1886 };
1887
1888 class CIfrToString : public CIfrObj, public CIfrOpHeader {
1889 private:
1890   EFI_IFR_TO_STRING *mToString;
1891
1892 public:
1893   CIfrToString (
1894   IN UINT32 LineNo
1895   ) : CIfrObj (EFI_IFR_TO_STRING_OP, (CHAR8 **)&mToString),
1896       CIfrOpHeader (EFI_IFR_TO_STRING_OP, &mToString->Header) {
1897     SetLineNo (LineNo);
1898   }
1899
1900   VOID SetFormat (IN UINT8 Format) {
1901     mToString->Format = Format;
1902   }
1903 };
1904
1905 class CIfrToUint : public CIfrObj, public CIfrOpHeader {
1906 private:
1907   EFI_IFR_TO_UINT *mToUint;
1908
1909 public:
1910   CIfrToUint (
1911   IN UINT32 LineNo
1912   ) : CIfrObj (EFI_IFR_TO_UINT_OP, (CHAR8 **)&mToUint),
1913       CIfrOpHeader (EFI_IFR_TO_UINT_OP, &mToUint->Header) {
1914     SetLineNo (LineNo);
1915   }
1916 };
1917
1918 class CIfrToUpper : public CIfrObj, public CIfrOpHeader {
1919 private:
1920   EFI_IFR_TO_UPPER *mToUpper;
1921
1922 public:
1923   CIfrToUpper (
1924   IN UINT32 LineNo
1925   ) : CIfrObj (EFI_IFR_TO_UPPER_OP, (CHAR8 **)&mToUpper),
1926       CIfrOpHeader (EFI_IFR_TO_UPPER_OP, &mToUpper->Header) {
1927     SetLineNo (LineNo);
1928   }
1929 };
1930
1931 class CIfrToLower : public CIfrObj, public CIfrOpHeader {
1932 private:
1933   EFI_IFR_TO_LOWER *mToLower;
1934
1935 public:
1936   CIfrToLower (
1937   IN UINT32 LineNo
1938   ) : CIfrObj (EFI_IFR_TO_LOWER_OP, (CHAR8 **)&mToLower),
1939       CIfrOpHeader (EFI_IFR_TO_LOWER_OP, &mToLower->Header) {
1940     SetLineNo (LineNo);
1941   }
1942 };
1943
1944 class CIfrAdd : public CIfrObj, public CIfrOpHeader {
1945 private:
1946   EFI_IFR_ADD *mAdd;
1947
1948 public:
1949   CIfrAdd (
1950   IN UINT32 LineNo
1951   ) : CIfrObj (EFI_IFR_ADD_OP, (CHAR8 **)&mAdd),
1952       CIfrOpHeader (EFI_IFR_ADD_OP, &mAdd->Header) {
1953     SetLineNo (LineNo);
1954   }
1955 };
1956
1957 class CIfrBitWiseAnd : public CIfrObj, public CIfrOpHeader {
1958 private:
1959   EFI_IFR_BITWISE_AND *mBitWiseAnd;
1960
1961 public:
1962   CIfrBitWiseAnd (
1963   IN UINT32 LineNo
1964   ) : CIfrObj (EFI_IFR_BITWISE_AND_OP, (CHAR8 **)&mBitWiseAnd),
1965       CIfrOpHeader (EFI_IFR_BITWISE_AND_OP, &mBitWiseAnd->Header) {
1966     SetLineNo(LineNo);
1967   }
1968 };
1969
1970 class CIfrBitWiseOr : public CIfrObj, public CIfrOpHeader {
1971 private:
1972   EFI_IFR_BITWISE_OR *mBitWiseOr;
1973
1974 public:
1975   CIfrBitWiseOr (
1976   IN UINT32 LineNo
1977   ) : CIfrObj (EFI_IFR_BITWISE_OR_OP, (CHAR8 **)&mBitWiseOr),
1978       CIfrOpHeader (EFI_IFR_BITWISE_OR_OP, &mBitWiseOr->Header) {
1979     SetLineNo (LineNo);
1980   }
1981 };
1982
1983 class CIfrAnd : public CIfrObj, public CIfrOpHeader {
1984 private:
1985   EFI_IFR_AND *mAnd;
1986
1987 public:
1988   CIfrAnd (
1989   IN UINT32 LineNo
1990   ) : CIfrObj (EFI_IFR_AND_OP, (CHAR8 **)&mAnd),
1991       CIfrOpHeader (EFI_IFR_AND_OP, &mAnd->Header) {
1992     SetLineNo (LineNo);
1993   }
1994 };
1995
1996 class CIfrCatenate : public CIfrObj, public CIfrOpHeader {
1997 private:
1998   EFI_IFR_CATENATE *mCatenate;
1999
2000 public:
2001   CIfrCatenate (
2002   IN UINT32 LineNo
2003   ) : CIfrObj (EFI_IFR_CATENATE_OP, (CHAR8 **)&mCatenate),
2004       CIfrOpHeader (EFI_IFR_CATENATE_OP, &mCatenate->Header) {
2005     SetLineNo (LineNo);
2006   }
2007 };
2008
2009 class CIfrDivide : public CIfrObj, public CIfrOpHeader {
2010 private:
2011   EFI_IFR_DIVIDE *mDivide;
2012
2013 public:
2014   CIfrDivide (
2015   IN UINT32 LineNo
2016   ) : CIfrObj (EFI_IFR_DIVIDE_OP, (CHAR8 **)&mDivide),
2017       CIfrOpHeader (EFI_IFR_DIVIDE_OP, &mDivide->Header) {
2018     SetLineNo (LineNo);
2019   }
2020 };
2021
2022 class CIfrEqual : public CIfrObj, public CIfrOpHeader {
2023 private:
2024   EFI_IFR_EQUAL *mEqual;
2025
2026 public:
2027   CIfrEqual (
2028   IN UINT32 LineNo
2029   ) : CIfrObj (EFI_IFR_EQUAL_OP, (CHAR8 **)&mEqual),
2030       CIfrOpHeader (EFI_IFR_EQUAL_OP, &mEqual->Header) {
2031     SetLineNo (LineNo);
2032   }
2033 };
2034
2035 class CIfrGreaterEqual : public CIfrObj, public CIfrOpHeader {
2036 private:
2037   EFI_IFR_GREATER_EQUAL *mGreaterEqual;
2038
2039 public:
2040   CIfrGreaterEqual (
2041   IN UINT32 LineNo
2042   ) : CIfrObj (EFI_IFR_GREATER_EQUAL_OP, (CHAR8 **)&mGreaterEqual),
2043       CIfrOpHeader (EFI_IFR_GREATER_EQUAL_OP, &mGreaterEqual->Header) {
2044     SetLineNo (LineNo);
2045   }
2046 };
2047
2048 class CIfrGreaterThan : public CIfrObj, public CIfrOpHeader {
2049 private:
2050   EFI_IFR_GREATER_THAN *mGreaterThan;
2051
2052 public:
2053   CIfrGreaterThan (
2054   IN UINT32 LineNo
2055   ) : CIfrObj (EFI_IFR_GREATER_THAN_OP, (CHAR8 **)&mGreaterThan),
2056       CIfrOpHeader (EFI_IFR_GREATER_THAN_OP, &mGreaterThan->Header) {
2057     SetLineNo (LineNo);
2058   }
2059 };
2060
2061 class CIfrLessEqual : public CIfrObj, public CIfrOpHeader {
2062 private:
2063   EFI_IFR_LESS_EQUAL *mLessEqual;
2064
2065 public:
2066   CIfrLessEqual (
2067   IN UINT32 LineNo
2068   ) : CIfrObj (EFI_IFR_LESS_EQUAL_OP, (CHAR8 **)&mLessEqual),
2069       CIfrOpHeader (EFI_IFR_LESS_EQUAL_OP, &mLessEqual->Header) {
2070     SetLineNo (LineNo);
2071   }
2072 };
2073
2074 class CIfrLessThan : public CIfrObj, public CIfrOpHeader {
2075 private:
2076   EFI_IFR_LESS_THAN *mLessThan;
2077
2078 public:
2079   CIfrLessThan (
2080   IN UINT32 LineNo
2081   ) : CIfrObj (EFI_IFR_LESS_THAN_OP, (CHAR8 **)&mLessThan),
2082       CIfrOpHeader (EFI_IFR_LESS_THAN_OP, &mLessThan->Header) {
2083     SetLineNo (LineNo);
2084   }
2085 };
2086
2087 class CIfrMatch : public CIfrObj, public CIfrOpHeader {
2088 private:
2089   EFI_IFR_MATCH *mMatch;
2090
2091 public:
2092   CIfrMatch (
2093   IN UINT32 LineNo
2094   ) : CIfrObj (EFI_IFR_MATCH_OP, (CHAR8 **)&mMatch),
2095       CIfrOpHeader (EFI_IFR_MATCH_OP, &mMatch->Header) {
2096     SetLineNo (LineNo);
2097   }
2098 };
2099
2100 class CIfrMultiply : public CIfrObj, public CIfrOpHeader {
2101 private:
2102   EFI_IFR_MULTIPLY *mMultiply;
2103
2104 public:
2105   CIfrMultiply (
2106   IN UINT32 LineNo
2107   ) : CIfrObj (EFI_IFR_MULTIPLY_OP, (CHAR8 **)&mMultiply),
2108       CIfrOpHeader (EFI_IFR_MULTIPLY_OP, &mMultiply->Header) {
2109     SetLineNo (LineNo);
2110   }
2111 };
2112
2113 class CIfrModulo : public CIfrObj, public CIfrOpHeader {
2114 private:
2115   EFI_IFR_MODULO *mModulo;
2116
2117 public:
2118   CIfrModulo (
2119   IN UINT32 LineNo
2120   ) : CIfrObj (EFI_IFR_MODULO_OP, (CHAR8 **)&mModulo),
2121       CIfrOpHeader (EFI_IFR_MODULO_OP, &mModulo->Header) {
2122     SetLineNo (LineNo);
2123   }
2124 };
2125
2126 class CIfrNotEqual : public CIfrObj, public CIfrOpHeader {
2127 private:
2128   EFI_IFR_NOT_EQUAL *mNotEqual;
2129
2130 public:
2131   CIfrNotEqual (
2132   IN UINT32 LineNo
2133   ) : CIfrObj (EFI_IFR_NOT_EQUAL_OP, (CHAR8 **)&mNotEqual),
2134       CIfrOpHeader (EFI_IFR_NOT_EQUAL_OP, &mNotEqual->Header) {
2135     SetLineNo (LineNo);
2136   }
2137 };
2138
2139 class CIfrOr : public CIfrObj, public CIfrOpHeader {
2140 private:
2141   EFI_IFR_OR *mOr;
2142
2143 public:
2144   CIfrOr (
2145   IN UINT32 LineNo
2146   ) : CIfrObj (EFI_IFR_OR_OP, (CHAR8 **)&mOr),
2147       CIfrOpHeader (EFI_IFR_OR_OP, &mOr->Header) {
2148     SetLineNo (LineNo);
2149   }
2150 };
2151
2152 class CIfrShiftLeft : public CIfrObj, public CIfrOpHeader {
2153 private:
2154   EFI_IFR_SHIFT_LEFT *mShiftLeft;
2155
2156 public:
2157   CIfrShiftLeft (
2158   IN UINT32 LineNo
2159   ) : CIfrObj (EFI_IFR_SHIFT_LEFT_OP, (CHAR8 **)&mShiftLeft),
2160       CIfrOpHeader (EFI_IFR_SHIFT_LEFT_OP, &mShiftLeft->Header) {
2161     SetLineNo (LineNo);
2162   }
2163 };
2164
2165 class CIfrShiftRight : public CIfrObj, public CIfrOpHeader {
2166 private:
2167   EFI_IFR_SHIFT_RIGHT *mShiftRight;
2168
2169 public:
2170   CIfrShiftRight (
2171   IN UINT32 LineNo
2172   ) : CIfrObj (EFI_IFR_SHIFT_RIGHT_OP, (CHAR8 **)&mShiftRight),
2173       CIfrOpHeader (EFI_IFR_SHIFT_RIGHT_OP, &mShiftRight->Header) {
2174     SetLineNo (LineNo);
2175   }
2176 };
2177
2178 class CIfrSubtract : public CIfrObj, public CIfrOpHeader {
2179 private:
2180   EFI_IFR_SUBTRACT *mSubtract;
2181
2182 public:
2183   CIfrSubtract (
2184   IN UINT32 LineNo
2185   ) : CIfrObj (EFI_IFR_SUBTRACT_OP, (CHAR8 **)&mSubtract),
2186       CIfrOpHeader (EFI_IFR_SUBTRACT_OP, &mSubtract->Header) {
2187     SetLineNo (LineNo);
2188   }
2189 };
2190
2191 class CIfrConditional : public CIfrObj, public CIfrOpHeader {
2192 private:
2193   EFI_IFR_CONDITIONAL *mConditional;
2194
2195 public:
2196   CIfrConditional (
2197   IN UINT32 LineNo
2198   ) : CIfrObj (EFI_IFR_CONDITIONAL_OP, (CHAR8 **)&mConditional),
2199       CIfrOpHeader (EFI_IFR_CONDITIONAL_OP, &mConditional->Header) {
2200     SetLineNo (LineNo);
2201   }
2202 };
2203
2204 class CIfrFind : public CIfrObj, public CIfrOpHeader {
2205 private:
2206   EFI_IFR_FIND *mFind;
2207
2208 public:
2209   CIfrFind (
2210   IN UINT32 LineNo
2211   ) : CIfrObj (EFI_IFR_FIND_OP, (CHAR8 **)&mFind),
2212       CIfrOpHeader (EFI_IFR_FIND_OP, &mFind->Header) {
2213     SetLineNo (LineNo);
2214   }
2215
2216   VOID SetFormat (IN UINT8 Format) {
2217     mFind->Format = Format;
2218   }
2219 };
2220
2221 class CIfrMid : public CIfrObj, public CIfrOpHeader {
2222 private:
2223   EFI_IFR_MID *mMid;
2224
2225 public:
2226   CIfrMid (
2227   IN UINT32 LineNo
2228   ) : CIfrObj (EFI_IFR_MID_OP, (CHAR8 **)&mMid),
2229       CIfrOpHeader (EFI_IFR_MID_OP, &mMid->Header) {
2230     SetLineNo (LineNo);
2231   }
2232 };
2233
2234 class CIfrToken : public CIfrObj, public CIfrOpHeader {
2235 private:
2236   EFI_IFR_TOKEN *mToken;
2237
2238 public:
2239   CIfrToken (
2240   IN UINT32 LineNo
2241   ) : CIfrObj (EFI_IFR_TOKEN_OP, (CHAR8 **)&mToken),
2242       CIfrOpHeader (EFI_IFR_TOKEN_OP, &mToken->Header) {
2243     SetLineNo (LineNo);
2244   }
2245 };
2246
2247 class CIfrSpan : public CIfrObj, public CIfrOpHeader {
2248 private:
2249   EFI_IFR_SPAN *mSpan;
2250
2251 public:
2252   CIfrSpan (
2253   IN UINT32 LineNo
2254   ) : CIfrObj (EFI_IFR_SPAN_OP, (CHAR8 **)&mSpan),
2255       CIfrOpHeader (EFI_IFR_SPAN_OP, &mSpan->Header) {
2256     SetLineNo (LineNo);
2257     mSpan->Flags = EFI_IFR_FLAGS_FIRST_MATCHING;
2258   }
2259
2260   EFI_VFR_RETURN_CODE SetFlags (IN UINT8 LFlags) {
2261     if (_IS_EQUAL (LFlags, EFI_IFR_FLAGS_FIRST_MATCHING)) {
2262       mSpan->Flags |= EFI_IFR_FLAGS_FIRST_MATCHING;
2263     } else if (_FLAG_TEST_AND_CLEAR (LFlags, EFI_IFR_FLAGS_FIRST_NON_MATCHING)) {
2264       mSpan->Flags |= EFI_IFR_FLAGS_FIRST_NON_MATCHING;
2265     }
2266
2267     return _FLAGS_ZERO (LFlags) ? VFR_RETURN_SUCCESS : VFR_RETURN_FLAGS_UNSUPPORTED;
2268   }
2269 };
2270
2271 #endif