BaseTools/Source/C/VfrCompile/VfrFormPkg.h

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