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

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