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 static CIfrObj            *gCurrentIfrOpcode = NULL;
 403
 404 /*
 405  * The definition of CIfrMinMaxStepData
 406  */
 407 class CIfrMinMaxStepData {
 408 private:
 409   MINMAXSTEP_DATA *mMinMaxStepData;
 410
 411 public:
 412   CIfrMinMaxStepData (MINMAXSTEP_DATA *DataAddr) : mMinMaxStepData (DataAddr) {
 413     mMinMaxStepData->u64.MinValue = 0;
 414     mMinMaxStepData->u64.MaxValue = 0;
 415     mMinMaxStepData->u64.Step     = 0;
 416   }
 417
 418   VOID SetMinMaxStepData (IN UINT64 MinValue, IN UINT64 MaxValue, IN UINT64 Step) {
 419     mMinMaxStepData->u64.MinValue = MinValue;
 420     mMinMaxStepData->u64.MaxValue = MaxValue;
 421     mMinMaxStepData->u64.Step     = Step;
 422   }
 423
 424   VOID SetMinMaxStepData (IN UINT32 MinValue, IN UINT32 MaxValue, IN UINT32 Step) {
 425     mMinMaxStepData->u32.MinValue = MinValue;
 426     mMinMaxStepData->u32.MaxValue = MaxValue;
 427     mMinMaxStepData->u32.Step     = Step;
 428   }
 429
 430   VOID SetMinMaxStepData (IN UINT16 MinValue, IN UINT16 MaxValue, IN UINT16 Step) {
 431     mMinMaxStepData->u16.MinValue = MinValue;
 432     mMinMaxStepData->u16.MaxValue = MaxValue;
 433     mMinMaxStepData->u16.Step     = Step;
 434   }
 435
 436   VOID SetMinMaxStepData (IN UINT8 MinValue, IN UINT8 MaxValue, IN UINT8 Step) {
 437     mMinMaxStepData->u8.MinValue = MinValue;
 438     mMinMaxStepData->u8.MaxValue = MaxValue;
 439     mMinMaxStepData->u8.Step     = Step;
 440   }
 441
 442 };
 443
 444 /*
 445  * The definition of all of the UEFI IFR Objects
 446  */
 447 class CIfrFormSet : public CIfrObj, public CIfrOpHeader {
 448 private:
 449   EFI_IFR_FORM_SET *mFormSet;
 450
 451 public:
 452   CIfrFormSet (UINT8 Size) : CIfrObj (EFI_IFR_FORM_SET_OP, (CHAR8 **)&mFormSet, Size),
 453                    CIfrOpHeader (EFI_IFR_FORM_SET_OP, &mFormSet->Header, Size) {
 454     mFormSet->Help         = EFI_STRING_ID_INVALID;
 455     mFormSet->FormSetTitle = EFI_STRING_ID_INVALID;
 456     mFormSet->Flags        = 0;
 457     memset (&mFormSet->Guid, 0, sizeof (EFI_GUID));
 458   }
 459
 460   VOID SetGuid (IN EFI_GUID *Guid) {
 461     memcpy (&mFormSet->Guid, Guid, sizeof (EFI_GUID));
 462   }
 463
 464   VOID SetFormSetTitle (IN EFI_STRING_ID FormSetTitle) {
 465     mFormSet->FormSetTitle = FormSetTitle;
 466   }
 467
 468   VOID SetHelp (IN EFI_STRING_ID Help) {
 469     mFormSet->Help = Help;
 470   }
 471
 472   VOID SetClassGuid (IN EFI_GUID *Guid) {
 473     memcpy (&(mFormSet->ClassGuid[mFormSet->Flags++]), Guid, sizeof (EFI_GUID));
 474   }
 475
 476   UINT8 GetFlags() {
 477     return mFormSet->Flags;
 478   }
 479 };
 480
 481 class CIfrEnd : public CIfrObj, public CIfrOpHeader {
 482 private:
 483   EFI_IFR_END  *mEnd;
 484
 485 public:
 486   CIfrEnd () : CIfrObj (EFI_IFR_END_OP, (CHAR8 **)&mEnd),
 487                CIfrOpHeader (EFI_IFR_END_OP, &mEnd->Header) {}
 488 };
 489
 490 class CIfrDefaultStore : public CIfrObj, public CIfrOpHeader {
 491 private:
 492   EFI_IFR_DEFAULTSTORE *mDefaultStore;
 493
 494 public:
 495   CIfrDefaultStore () : CIfrObj (EFI_IFR_DEFAULTSTORE_OP, (CHAR8 **)&mDefaultStore),
 496                        CIfrOpHeader (EFI_IFR_DEFAULTSTORE_OP, &mDefaultStore->Header) {
 497     mDefaultStore->DefaultId   = EFI_VARSTORE_ID_INVALID;
 498     mDefaultStore->DefaultName = EFI_STRING_ID_INVALID;
 499   }
 500
 501   VOID SetDefaultName (IN EFI_STRING_ID DefaultName) {
 502     mDefaultStore->DefaultName = DefaultName;
 503   }
 504
 505   VOID SetDefaultId (IN UINT16 DefaultId) {
 506     mDefaultStore->DefaultId = DefaultId;
 507   }
 508 };
 509
 510 #define EFI_FORM_ID_MAX                    0xFFFF
 511 #define EFI_FREE_FORM_ID_BITMAP_SIZE     ((EFI_FORM_ID_MAX + 1) / EFI_BITS_PER_UINT32)
 512
 513 class CIfrForm : public CIfrObj, public CIfrOpHeader {
 514 private:
 515   EFI_IFR_FORM  *mForm;
 516
 517   STATIC UINT32 FormIdBitMap[EFI_FREE_FORM_ID_BITMAP_SIZE];
 518
 519   STATIC BOOLEAN ChekFormIdFree (IN EFI_FORM_ID FormId) {
 520     UINT32 Index  = (FormId / EFI_BITS_PER_UINT32);
 521     UINT32 Offset = (FormId % EFI_BITS_PER_UINT32);
 522
 523     return (FormIdBitMap[Index] & (0x80000000 >> Offset)) == 0;
 524   }
 525
 526   STATIC VOID MarkFormIdUsed (IN EFI_FORM_ID FormId) {
 527     UINT32 Index  = (FormId / EFI_BITS_PER_UINT32);
 528     UINT32 Offset = (FormId % EFI_BITS_PER_UINT32);
 529
 530     FormIdBitMap[Index] |= (0x80000000 >> Offset);
 531   }
 532
 533 public:
 534   CIfrForm () : CIfrObj (EFI_IFR_FORM_OP, (CHAR8 **)&mForm),
 535                 CIfrOpHeader (EFI_IFR_FORM_OP, &mForm->Header) {
 536     mForm->FormId    = 0;
 537     mForm->FormTitle = EFI_STRING_ID_INVALID;
 538   }
 539
 540   EFI_VFR_RETURN_CODE SetFormId (IN EFI_FORM_ID FormId) {
 541     if (FormId == 0) {
 542       //
 543       // FormId can't be 0.
 544       //
 545       return VFR_RETURN_INVALID_PARAMETER;
 546     }
 547     if (CIfrForm::ChekFormIdFree (FormId) == FALSE) {
 548       return VFR_RETURN_FORMID_REDEFINED;
 549     }
 550     mForm->FormId = FormId;
 551     CIfrForm::MarkFormIdUsed (FormId);
 552     return VFR_RETURN_SUCCESS;
 553   }
 554
 555   VOID SetFormTitle (IN EFI_STRING_ID FormTitle) {
 556     mForm->FormTitle = FormTitle;
 557   }
 558 };
 559
 560 class CIfrVarStore : public CIfrObj, public CIfrOpHeader {
 561 private:
 562   EFI_IFR_VARSTORE *mVarStore;
 563
 564 public:
 565   CIfrVarStore () : CIfrObj (EFI_IFR_VARSTORE_OP, (CHAR8 **)&mVarStore, sizeof (EFI_IFR_VARSTORE), TRUE),
 566                    CIfrOpHeader (EFI_IFR_VARSTORE_OP, &mVarStore->Header) {
 567     mVarStore->VarStoreId = EFI_VARSTORE_ID_INVALID;
 568     mVarStore->Size       = 0;
 569     memset (&mVarStore->Guid, 0, sizeof (EFI_GUID));
 570     mVarStore->Name[0]    = '\0';
 571   }
 572
 573   VOID SetGuid (IN EFI_GUID *Guid) {
 574     memcpy (&mVarStore->Guid, Guid, sizeof (EFI_GUID));
 575   }
 576
 577   VOID SetVarStoreId (IN EFI_VARSTORE_ID VarStoreId) {
 578     mVarStore->VarStoreId = VarStoreId;
 579   }
 580
 581   VOID SetSize (IN UINT16 Size) {
 582     mVarStore->Size = Size;
 583   }
 584
 585   VOID SetName (IN CHAR8 *Name) {
 586     UINT8 Len;
 587
 588     if (Name != NULL) {
 589       Len = strlen (Name);
 590       if (Len != 0) {
 591         if (ExpendObjBin (Len) == TRUE) {
 592           IncLength (Len);
 593           strcpy ((CHAR8 *)(mVarStore->Name), Name);
 594         }
 595       }
 596     }
 597   }
 598 };
 599
 600 class CIfrVarStoreEfi : public CIfrObj, public CIfrOpHeader {
 601 private:
 602   EFI_IFR_VARSTORE_EFI *mVarStoreEfi;
 603
 604 public:
 605   CIfrVarStoreEfi () : CIfrObj (EFI_IFR_VARSTORE_EFI_OP, (CHAR8 **)&mVarStoreEfi),
 606                       CIfrOpHeader (EFI_IFR_VARSTORE_EFI_OP, &mVarStoreEfi->Header) {
 607     mVarStoreEfi->VarStoreId = EFI_VAROFFSET_INVALID;
 608     memset (&mVarStoreEfi->Guid, 0, sizeof (EFI_GUID));
 609   }
 610
 611   VOID SetGuid (IN EFI_GUID *Guid) {
 612     memcpy (&mVarStoreEfi->Guid, Guid, sizeof (EFI_GUID));
 613   }
 614
 615   VOID SetVarStoreId (IN UINT16 VarStoreId) {
 616     mVarStoreEfi->VarStoreId = VarStoreId;
 617   }
 618
 619   VOID SetAttributes (IN UINT32 Attributes) {
 620     mVarStoreEfi->Attributes = Attributes;
 621   }
 622 };
 623
 624 class CIfrVarStoreNameValue : public CIfrObj, public CIfrOpHeader {
 625 private:
 626   EFI_IFR_VARSTORE_NAME_VALUE *mVarStoreNameValue;
 627
 628 public:
 629   CIfrVarStoreNameValue () : CIfrObj (EFI_IFR_VARSTORE_NAME_VALUE_OP, (CHAR8 **)&mVarStoreNameValue),
 630                               CIfrOpHeader (EFI_IFR_VARSTORE_NAME_VALUE_OP, &mVarStoreNameValue->Header) {
 631     mVarStoreNameValue->VarStoreId = EFI_VAROFFSET_INVALID;
 632     memset (&mVarStoreNameValue->Guid, 0, sizeof (EFI_GUID));
 633   }
 634
 635   VOID SetGuid (IN EFI_GUID *Guid) {
 636     memcpy (&mVarStoreNameValue->Guid, Guid, sizeof (EFI_GUID));
 637   }
 638
 639   VOID SetVarStoreId (IN UINT16 VarStoreId) {
 640     mVarStoreNameValue->VarStoreId = VarStoreId;
 641   }
 642 };
 643
 644 class CIfrImage : public CIfrObj, public CIfrOpHeader {
 645 private:
 646   EFI_IFR_IMAGE *mImage;
 647
 648 public:
 649   CIfrImage () : CIfrObj (EFI_IFR_IMAGE_OP, (CHAR8 **)&mImage),
 650                  CIfrOpHeader (EFI_IFR_FORM_OP, &mImage->Header) {
 651     mImage->Id = EFI_IMAGE_ID_INVALID;
 652   }
 653
 654   VOID SetImageId (IN EFI_IMAGE_ID ImageId) {
 655     mImage->Id = ImageId;
 656   }
 657 };
 658
 659 class CIfrLocked : public CIfrObj, public CIfrOpHeader {
 660 private:
 661   EFI_IFR_LOCKED *mLocked;
 662
 663 public:
 664   CIfrLocked () : CIfrObj (EFI_IFR_LOCKED_OP, (CHAR8 **)&mLocked),
 665                   CIfrOpHeader (EFI_IFR_LOCKED_OP, &mLocked->Header) {}
 666 };
 667
 668 class CIfrRule : public CIfrObj, public CIfrOpHeader {
 669 private:
 670   EFI_IFR_RULE *mRule;
 671
 672 public:
 673   CIfrRule () : CIfrObj (EFI_IFR_RULE_OP, (CHAR8 **)&mRule),
 674                 mRule ((EFI_IFR_RULE *)GetObjBinAddr()),
 675                 CIfrOpHeader (EFI_IFR_RULE_OP, &mRule->Header) {
 676     mRule->RuleId = EFI_RULE_ID_INVALID;
 677   }
 678
 679   VOID SetRuleId (IN UINT8 RuleId) {
 680     mRule->RuleId = RuleId;
 681   }
 682 };
 683
 684 static EFI_IFR_TYPE_VALUE gZeroEfiIfrTypeValue = {0, };
 685
 686 class CIfrDefault : public CIfrObj, public CIfrOpHeader {
 687 private:
 688   EFI_IFR_DEFAULT *mDefault;
 689
 690 public:
 691   CIfrDefault (
 692     IN UINT16             DefaultId = EFI_HII_DEFAULT_CLASS_STANDARD,
 693     IN UINT8              Type      = EFI_IFR_TYPE_OTHER,
 694     IN EFI_IFR_TYPE_VALUE Value     = gZeroEfiIfrTypeValue
 695     ) : CIfrObj (EFI_IFR_DEFAULT_OP, (CHAR8 **)&mDefault),
 696         CIfrOpHeader (EFI_IFR_DEFAULT_OP, &mDefault->Header) {
 697     mDefault->Type      = Type;
 698     mDefault->Value     = Value;
 699     mDefault->DefaultId = DefaultId;
 700   }
 701
 702   VOID SetDefaultId (IN UINT16 DefaultId) {
 703     mDefault->DefaultId = DefaultId;
 704   }
 705
 706   VOID SetType (IN UINT8 Type) {
 707     mDefault->Type = Type;
 708   }
 709
 710   VOID SetValue (IN EFI_IFR_TYPE_VALUE Value) {
 711     mDefault->Value = Value;
 712   }
 713 };
 714
 715 class CIfrValue : public CIfrObj, public CIfrOpHeader{
 716 private:
 717   EFI_IFR_VALUE *mValue;
 718
 719 public:
 720   CIfrValue () : CIfrObj (EFI_IFR_VALUE_OP, (CHAR8 **)&mValue),
 721                 CIfrOpHeader (EFI_IFR_VALUE_OP, &mValue->Header) {}
 722
 723 };
 724
 725 class CIfrSubtitle : public CIfrObj, public CIfrOpHeader, public CIfrStatementHeader {
 726 private:
 727   EFI_IFR_SUBTITLE   *mSubtitle;
 728
 729 public:
 730   CIfrSubtitle () : CIfrObj (EFI_IFR_SUBTITLE_OP, (CHAR8 **)&mSubtitle),
 731                   CIfrOpHeader (EFI_IFR_SUBTITLE_OP, &mSubtitle->Header),
 732   CIfrStatementHeader (&mSubtitle->Statement) {
 733     mSubtitle->Flags = 0;
 734   }
 735
 736   EFI_VFR_RETURN_CODE SetFlags (IN UINT8 LFlags) {
 737     if (_FLAG_TEST_AND_CLEAR (LFlags, EFI_IFR_FLAGS_HORIZONTAL)) {
 738       mSubtitle->Flags |= EFI_IFR_FLAGS_HORIZONTAL;
 739     }
 740
 741     return _FLAGS_ZERO (LFlags) ? VFR_RETURN_SUCCESS : VFR_RETURN_FLAGS_UNSUPPORTED;
 742   }
 743 };
 744
 745 class CIfrText : public CIfrObj, public CIfrOpHeader, public CIfrStatementHeader {
 746 private:
 747   EFI_IFR_TEXT *mText;
 748
 749 public:
 750   CIfrText () : CIfrObj (EFI_IFR_TEXT_OP, (CHAR8 **)&mText),
 751                CIfrOpHeader (EFI_IFR_TEXT_OP, &mText->Header),
 752                CIfrStatementHeader (&mText->Statement) {
 753     mText->TextTwo = EFI_STRING_ID_INVALID;
 754   }
 755
 756   VOID SetTextTwo (IN EFI_STRING_ID StringId) {
 757     mText->TextTwo = StringId;
 758   }
 759 };
 760
 761 class CIfrRef : public CIfrObj, public CIfrOpHeader, public CIfrQuestionHeader {
 762 private:
 763   EFI_IFR_REF *mRef;
 764
 765 public:
 766   CIfrRef () : CIfrObj (EFI_IFR_REF_OP, (CHAR8 **)&mRef),
 767               CIfrOpHeader (EFI_IFR_REF_OP, &mRef->Header),
 768               CIfrQuestionHeader (&mRef->Question) {
 769     mRef->FormId = 0;
 770   }
 771
 772   VOID SetFormId (IN EFI_FORM_ID FormId) {
 773     mRef->FormId = FormId;
 774   }
 775 };
 776
 777 class CIfrRef2 : public CIfrObj, public CIfrOpHeader, public CIfrQuestionHeader {
 778 private:
 779   EFI_IFR_REF2 *mRef2;
 780
 781 public:
 782   CIfrRef2 () : CIfrObj (EFI_IFR_REF_OP, (CHAR8 **)&mRef2, sizeof (EFI_IFR_REF2)),
 783                CIfrOpHeader (EFI_IFR_REF_OP, &mRef2->Header, sizeof (EFI_IFR_REF2)),
 784                CIfrQuestionHeader (&mRef2->Question) {
 785     mRef2->FormId     = 0;
 786     mRef2->QuestionId = EFI_QUESTION_ID_INVALID;
 787   }
 788
 789   VOID SetFormId (IN EFI_FORM_ID FormId) {
 790     mRef2->FormId = FormId;
 791   }
 792
 793   EFI_VFR_RETURN_CODE SetQuestionId (IN EFI_QUESTION_ID QuestionId) {
 794     if (QuestionId == EFI_QUESTION_ID_INVALID) {
 795       return VFR_RETURN_UNDEFINED;
 796     }
 797     mRef2->QuestionId = QuestionId;
 798     return VFR_RETURN_SUCCESS;
 799   }
 800 };
 801
 802 class CIfrRef3 : public CIfrObj, public CIfrOpHeader, public CIfrQuestionHeader {
 803 private:
 804   EFI_IFR_REF3 *mRef3;
 805
 806 public:
 807   CIfrRef3 () : CIfrObj (EFI_IFR_REF_OP, (CHAR8 **)&mRef3, sizeof(EFI_IFR_REF3)),
 808                CIfrOpHeader (EFI_IFR_REF_OP, &mRef3->Header, sizeof (EFI_IFR_REF3)),
 809                CIfrQuestionHeader (&mRef3->Question) {
 810     mRef3->FormId     = 0;
 811     mRef3->QuestionId = EFI_QUESTION_ID_INVALID;
 812     memset (&mRef3->FormSetId, 0, sizeof (EFI_GUID));
 813   }
 814
 815   VOID SetFormId (IN EFI_FORM_ID FormId) {
 816     mRef3->FormId = FormId;
 817   }
 818
 819   VOID SetQuestionId (IN EFI_QUESTION_ID QuestionId) {
 820     mRef3->QuestionId = QuestionId;
 821   }
 822
 823   VOID SetFormSetId (IN EFI_GUID FormSetId) {
 824     mRef3->FormSetId = FormSetId;
 825   }
 826 };
 827
 828 class CIfrRef4 : public CIfrObj, public CIfrOpHeader, public CIfrQuestionHeader {
 829 private:
 830   EFI_IFR_REF4 *mRef4;
 831
 832 public:
 833   CIfrRef4 () : CIfrObj (EFI_IFR_REF_OP, (CHAR8 **)&mRef4, sizeof(EFI_IFR_REF3)),
 834                CIfrOpHeader (EFI_IFR_REF_OP, &mRef4->Header, sizeof (EFI_IFR_REF3)),
 835                CIfrQuestionHeader (&mRef4->Question) {
 836     mRef4->FormId     = 0;
 837     mRef4->QuestionId = EFI_QUESTION_ID_INVALID;
 838     memset (&mRef4->FormSetId, 0, sizeof (EFI_GUID));
 839     mRef4->DevicePath = EFI_STRING_ID_INVALID;
 840   }
 841
 842   VOID SetFormId (IN EFI_FORM_ID FormId) {
 843     mRef4->FormId = FormId;
 844   }
 845
 846   VOID SetQuestionId (IN EFI_QUESTION_ID QuestionId) {
 847     mRef4->QuestionId = QuestionId;
 848   }
 849
 850   VOID SetFormSetId (IN EFI_GUID FormSetId) {
 851     mRef4->FormSetId = FormSetId;
 852   }
 853
 854   VOID SetDevicePath (IN EFI_STRING_ID DevicePath) {
 855     mRef4->DevicePath = DevicePath;
 856   }
 857 };
 858
 859 class CIfrResetButton : public CIfrObj, public CIfrOpHeader, public CIfrStatementHeader {
 860 private:
 861   EFI_IFR_RESET_BUTTON *mResetButton;
 862
 863 public:
 864   CIfrResetButton () : CIfrObj (EFI_IFR_RESET_BUTTON_OP, (CHAR8 **)&mResetButton),
 865                        CIfrOpHeader (EFI_IFR_RESET_BUTTON_OP, &mResetButton->Header),
 866   CIfrStatementHeader (&mResetButton->Statement) {
 867     mResetButton->DefaultId = EFI_HII_DEFAULT_CLASS_STANDARD;
 868   }
 869
 870   VOID SetDefaultId (IN UINT16 DefaultId) {
 871     mResetButton->DefaultId = DefaultId;
 872   }
 873 };
 874
 875 class CIfrCheckBox : public CIfrObj, public CIfrOpHeader, public CIfrQuestionHeader  {
 876 private:
 877   EFI_IFR_CHECKBOX *mCheckBox;
 878
 879 public:
 880   CIfrCheckBox () : CIfrObj (EFI_IFR_CHECKBOX_OP, (CHAR8 **)&mCheckBox),
 881                      CIfrOpHeader (EFI_IFR_CHECKBOX_OP, &mCheckBox->Header),
 882                      CIfrQuestionHeader (&mCheckBox->Question) {
 883     mCheckBox->Flags = 0;
 884     gCurrentQuestion  = this;
 885   }
 886
 887   ~CIfrCheckBox () {
 888     gCurrentQuestion  = NULL;
 889   }
 890
 891   EFI_VFR_RETURN_CODE SetFlags (IN UINT8 HFlags, UINT8 LFlags) {
 892     EFI_VFR_RETURN_CODE Ret;
 893
 894     Ret = CIfrQuestionHeader::SetFlags (HFlags);
 895     if (Ret != VFR_RETURN_SUCCESS) {
 896       return Ret;
 897     }
 898
 899     if (_FLAG_TEST_AND_CLEAR (LFlags, EFI_IFR_CHECKBOX_DEFAULT)) {
 900       mCheckBox->Flags |= EFI_IFR_CHECKBOX_DEFAULT;
 901     }
 902
 903     if (_FLAG_TEST_AND_CLEAR (LFlags, EFI_IFR_CHECKBOX_DEFAULT_MFG)) {
 904       mCheckBox->Flags |= EFI_IFR_CHECKBOX_DEFAULT_MFG;
 905     }
 906
 907     return _FLAGS_ZERO (LFlags) ? VFR_RETURN_SUCCESS : VFR_RETURN_FLAGS_UNSUPPORTED;
 908   }
 909
 910   UINT8 GetFlags (VOID) {
 911     return mCheckBox->Flags;
 912   }
 913 };
 914
 915 class CIfrAction : public CIfrObj, public CIfrOpHeader, public CIfrQuestionHeader {
 916 private:
 917   EFI_IFR_ACTION *mAction;
 918
 919 public:
 920   CIfrAction () : CIfrObj (EFI_IFR_ACTION_OP, (CHAR8 **)&mAction),
 921                  CIfrOpHeader (EFI_IFR_ACTION_OP, &mAction->Header),
 922                  CIfrQuestionHeader (&mAction->Question) {
 923     mAction->QuestionConfig = EFI_STRING_ID_INVALID;
 924   }
 925
 926   VOID SetQuestionConfig (IN EFI_STRING_ID QuestionConfig) {
 927     mAction->QuestionConfig = QuestionConfig;
 928   }
 929 };
 930
 931 class CIfrDate : public CIfrObj, public CIfrOpHeader, public CIfrQuestionHeader {
 932 private:
 933   EFI_IFR_DATE *mDate;
 934
 935 public:
 936   CIfrDate () : CIfrObj (EFI_IFR_DATE_OP, (CHAR8 **)&mDate),
 937                CIfrOpHeader (EFI_IFR_DATE_OP, &mDate->Header),
 938                CIfrQuestionHeader (&mDate->Question) {
 939     mDate->Flags = 0;
 940   }
 941
 942   EFI_VFR_RETURN_CODE SetFlags (IN UINT8 HFlags, IN UINT8 LFlags) {
 943     EFI_VFR_RETURN_CODE Ret;
 944
 945     Ret = CIfrQuestionHeader::SetFlags (HFlags);
 946     if (Ret != VFR_RETURN_SUCCESS) {
 947       return Ret;
 948     }
 949
 950     if (_FLAG_TEST_AND_CLEAR (LFlags, EFI_QF_DATE_YEAR_SUPPRESS)) {
 951       mDate->Flags |= EFI_QF_DATE_YEAR_SUPPRESS;
 952     }
 953
 954     if (_FLAG_TEST_AND_CLEAR (LFlags, EFI_QF_DATE_MONTH_SUPPRESS)) {
 955       mDate->Flags |= EFI_QF_DATE_MONTH_SUPPRESS;
 956     }
 957
 958     if (_FLAG_TEST_AND_CLEAR (LFlags, EFI_QF_DATE_DAY_SUPPRESS)) {
 959       mDate->Flags |= EFI_QF_DATE_DAY_SUPPRESS;
 960     }
 961
 962     if (_FLAG_TEST_AND_CLEAR (LFlags, QF_DATE_STORAGE_NORMAL)) {
 963       mDate->Flags |= QF_DATE_STORAGE_NORMAL;
 964     } else if (_FLAG_TEST_AND_CLEAR (LFlags, QF_DATE_STORAGE_TIME)) {
 965       mDate->Flags |= QF_DATE_STORAGE_TIME;
 966     } else if (_FLAG_TEST_AND_CLEAR (LFlags, QF_DATE_STORAGE_WAKEUP)) {
 967       mDate->Flags |= QF_DATE_STORAGE_WAKEUP;
 968     }
 969
 970     return _FLAGS_ZERO (LFlags) ? VFR_RETURN_SUCCESS : VFR_RETURN_FLAGS_UNSUPPORTED;
 971   }
 972 };
 973
 974 class CIfrNumeric : public CIfrObj, public CIfrOpHeader, public CIfrQuestionHeader, public CIfrMinMaxStepData {
 975 private:
 976   EFI_IFR_NUMERIC *mNumeric;
 977
 978 public:
 979   CIfrNumeric () : CIfrObj (EFI_IFR_NUMERIC_OP, (CHAR8 **)&mNumeric),
 980                    CIfrOpHeader (EFI_IFR_NUMERIC_OP, &mNumeric->Header),
 981                    CIfrQuestionHeader (&mNumeric->Question),
 982                    CIfrMinMaxStepData (&mNumeric->data) {
 983     mNumeric->Flags  = EFI_IFR_NUMERIC_SIZE_1 | EFI_IFR_DISPLAY_UINT_DEC;
 984     gCurrentQuestion  = this;
 985     gCurrentIfrOpcode = this;
 986   }
 987
 988   ~CIfrNumeric () {
 989     gCurrentQuestion  = NULL;
 990     gCurrentIfrOpcode = NULL;
 991   }
 992
 993   EFI_VFR_RETURN_CODE SetFlags (IN UINT8 HFlags, IN UINT8 LFlags) {
 994     EFI_VFR_RETURN_CODE Ret;
 995
 996     Ret = CIfrQuestionHeader::SetFlags (HFlags);
 997     if (Ret != VFR_RETURN_SUCCESS) {
 998       return Ret;
 999     }
1000
1001     if (LFlags & EFI_IFR_DISPLAY) {
1002       mNumeric->Flags = LFlags;
1003     } else {
1004       mNumeric->Flags = LFlags | EFI_IFR_DISPLAY_UINT_DEC;
1005     }
1006     return VFR_RETURN_SUCCESS;
1007   }
1008 };
1009
1010 class CIfrOneOf : public CIfrObj, public CIfrOpHeader, public CIfrQuestionHeader, public CIfrMinMaxStepData {
1011 private:
1012   EFI_IFR_ONE_OF *mOneOf;
1013
1014 public:
1015   CIfrOneOf () : CIfrObj (EFI_IFR_ONE_OF_OP, (CHAR8 **)&mOneOf),
1016                  CIfrOpHeader (EFI_IFR_ONE_OF_OP, &mOneOf->Header),
1017                  CIfrQuestionHeader (&mOneOf->Question),
1018                  CIfrMinMaxStepData (&mOneOf->data) {
1019     mOneOf->Flags    = 0;
1020     gCurrentQuestion  = this;
1021     gCurrentIfrOpcode = this;
1022   }
1023
1024   ~CIfrOneOf () {
1025     gCurrentQuestion  = NULL;
1026     gCurrentIfrOpcode = NULL;
1027   }
1028
1029   EFI_VFR_RETURN_CODE SetFlags (IN UINT8 HFlags, IN UINT8 LFlags) {
1030     EFI_VFR_RETURN_CODE Ret;
1031
1032     Ret = CIfrQuestionHeader::SetFlags (HFlags);
1033     if (Ret != VFR_RETURN_SUCCESS) {
1034       return Ret;
1035     }
1036
1037     if (LFlags & EFI_IFR_DISPLAY) {
1038       mOneOf->Flags = LFlags;
1039     } else {
1040       mOneOf->Flags = LFlags | EFI_IFR_DISPLAY_UINT_DEC;
1041     }
1042     return VFR_RETURN_SUCCESS;
1043   }
1044 };
1045
1046 class CIfrString : public CIfrObj, public CIfrOpHeader, public CIfrQuestionHeader {
1047 private:
1048   EFI_IFR_STRING *mString;
1049
1050 public:
1051   CIfrString () : CIfrObj (EFI_IFR_STRING_OP, (CHAR8 **)&mString),
1052                  CIfrOpHeader (EFI_IFR_STRING_OP, &mString->Header),
1053                  CIfrQuestionHeader (&mString->Question) {
1054     mString->Flags   = 0;
1055     mString->MinSize = 0;
1056     mString->MaxSize = 0;
1057     gCurrentQuestion = this;
1058   }
1059
1060   ~CIfrString () {
1061     gCurrentQuestion = NULL;
1062   }
1063
1064   EFI_VFR_RETURN_CODE SetFlags (IN UINT8 HFlags, IN UINT8 LFlags) {
1065     EFI_VFR_RETURN_CODE Ret;
1066
1067     Ret = CIfrQuestionHeader::SetFlags (HFlags);
1068     if (Ret != VFR_RETURN_SUCCESS) {
1069       return Ret;
1070     }
1071
1072     if (_FLAG_TEST_AND_CLEAR (LFlags, EFI_IFR_STRING_MULTI_LINE)) {
1073       mString->Flags |= EFI_IFR_STRING_MULTI_LINE;
1074     }
1075
1076     return _FLAGS_ZERO (LFlags) ? VFR_RETURN_SUCCESS : VFR_RETURN_FLAGS_UNSUPPORTED;
1077   }
1078
1079   VOID SetMinSize (IN UINT8 Flags) {
1080     mString->MinSize = Flags;
1081   }
1082
1083   VOID SetMaxSize (IN UINT8 MaxSize) {
1084     mString->MaxSize = MaxSize;
1085   }
1086 };
1087
1088 class CIfrPassword : public CIfrObj, public CIfrOpHeader, public CIfrQuestionHeader {
1089 private:
1090   EFI_IFR_PASSWORD *mPassword;
1091
1092 public:
1093   CIfrPassword () : CIfrObj (EFI_IFR_PASSWORD_OP, (CHAR8 **)&mPassword),
1094                     CIfrOpHeader (EFI_IFR_PASSWORD_OP, &mPassword->Header),
1095                     CIfrQuestionHeader (&mPassword->Question) {
1096     mPassword->MinSize = 0;
1097     mPassword->MaxSize = 0;
1098     gCurrentQuestion   = this;
1099   }
1100
1101   ~CIfrPassword () {
1102     gCurrentQuestion = NULL;
1103   }
1104
1105   VOID SetMinSize (IN UINT16 MinSize) {
1106     mPassword->MinSize = MinSize;
1107   }
1108
1109   VOID SetMaxSize (IN UINT16 MaxSize) {
1110     mPassword->MaxSize = MaxSize;
1111   }
1112 };
1113
1114 class CIfrOrderedList : public CIfrObj, public CIfrOpHeader, public CIfrQuestionHeader {
1115 private:
1116   EFI_IFR_ORDERED_LIST *mOrderedList;
1117
1118 public:
1119   CIfrOrderedList () : CIfrObj (EFI_IFR_ORDERED_LIST_OP, (CHAR8 **)&mOrderedList),
1120                       CIfrOpHeader (EFI_IFR_ORDERED_LIST_OP, &mOrderedList->Header),
1121                       CIfrQuestionHeader (&mOrderedList->Question) {
1122     mOrderedList->MaxContainers = 0;
1123     mOrderedList->Flags         = 0;
1124     gCurrentQuestion            = this;
1125   }
1126
1127   ~CIfrOrderedList () {
1128     gCurrentQuestion = NULL;
1129   }
1130
1131   VOID SetMaxContainers (IN UINT8 MaxContainers) {
1132     mOrderedList->MaxContainers = MaxContainers;
1133   }
1134
1135   EFI_VFR_RETURN_CODE SetFlags (IN UINT8 HFlags, IN UINT8 LFlags) {
1136     EFI_VFR_RETURN_CODE Ret;
1137
1138     Ret = CIfrQuestionHeader::SetFlags (HFlags);
1139     if (Ret != VFR_RETURN_SUCCESS) {
1140       return Ret;
1141     }
1142
1143     if (_FLAG_TEST_AND_CLEAR (LFlags, EFI_IFR_UNIQUE_SET)) {
1144       mOrderedList->Flags |= EFI_IFR_UNIQUE_SET;
1145     }
1146
1147     if (_FLAG_TEST_AND_CLEAR (LFlags, EFI_IFR_NO_EMPTY_SET)) {
1148       mOrderedList->Flags |= EFI_IFR_NO_EMPTY_SET;
1149     }
1150
1151     return _FLAGS_ZERO (LFlags) ? VFR_RETURN_SUCCESS : VFR_RETURN_FLAGS_UNSUPPORTED;
1152   }
1153 };
1154
1155 class CIfrTime : public CIfrObj, public CIfrOpHeader, public CIfrQuestionHeader {
1156 private:
1157   EFI_IFR_TIME *mTime;
1158
1159 public:
1160   CIfrTime () : CIfrObj (EFI_IFR_TIME_OP, (CHAR8 **)&mTime),
1161                 CIfrOpHeader (EFI_IFR_TIME_OP, &mTime->Header),
1162                 CIfrQuestionHeader (&mTime->Question) {
1163     mTime->Flags = 0;
1164   }
1165
1166   EFI_VFR_RETURN_CODE SetFlags (IN UINT8 HFlags, IN UINT8 LFlags) {
1167     EFI_VFR_RETURN_CODE Ret;
1168
1169     Ret = CIfrQuestionHeader::SetFlags (HFlags);
1170     if (Ret != VFR_RETURN_SUCCESS) {
1171       return Ret;
1172     }
1173
1174     if (_FLAG_TEST_AND_CLEAR (LFlags, QF_TIME_HOUR_SUPPRESS)) {
1175       mTime->Flags |= QF_TIME_HOUR_SUPPRESS;
1176     }
1177
1178     if (_FLAG_TEST_AND_CLEAR (LFlags, QF_TIME_MINUTE_SUPPRESS)) {
1179       mTime->Flags |= QF_TIME_MINUTE_SUPPRESS;
1180     }
1181
1182     if (_FLAG_TEST_AND_CLEAR (LFlags, QF_TIME_SECOND_SUPPRESS)) {
1183       mTime->Flags |= QF_TIME_SECOND_SUPPRESS;
1184     }
1185
1186     if (_FLAG_TEST_AND_CLEAR (LFlags, QF_TIME_STORAGE_NORMAL)) {
1187       mTime->Flags |= QF_TIME_STORAGE_NORMAL;
1188     } else if (_FLAG_TEST_AND_CLEAR (LFlags, QF_TIME_STORAGE_TIME)) {
1189       mTime->Flags |= QF_TIME_STORAGE_TIME;
1190     } else if (_FLAG_TEST_AND_CLEAR (LFlags, QF_TIME_STORAGE_WAKEUP)) {
1191       mTime->Flags |= QF_TIME_STORAGE_WAKEUP;
1192     }
1193
1194     return _FLAGS_ZERO (LFlags) ? VFR_RETURN_SUCCESS : VFR_RETURN_FLAGS_UNSUPPORTED;
1195   }
1196 };
1197
1198 class CIfrDisableIf : public CIfrObj, public CIfrOpHeader {
1199 private:
1200   EFI_IFR_DISABLE_IF *mDisableIf;
1201
1202 public:
1203   CIfrDisableIf () : CIfrObj (EFI_IFR_DISABLE_IF_OP, (CHAR8 **)&mDisableIf),
1204                    mDisableIf ((EFI_IFR_DISABLE_IF *) GetObjBinAddr()),
1205                    CIfrOpHeader (EFI_IFR_DISABLE_IF_OP, &mDisableIf->Header) {}
1206 };
1207
1208 class CIfrSuppressIf : public CIfrObj, public CIfrOpHeader {
1209 private:
1210   EFI_IFR_SUPPRESS_IF *mSuppressIf;
1211
1212 public:
1213   CIfrSuppressIf () : CIfrObj (EFI_IFR_SUPPRESS_IF_OP, (CHAR8 **)&mSuppressIf),
1214                      CIfrOpHeader (EFI_IFR_SUPPRESS_IF_OP, &mSuppressIf->Header) {}
1215 };
1216
1217 class CIfrGrayOutIf : public CIfrObj, public CIfrOpHeader {
1218 private:
1219   EFI_IFR_GRAY_OUT_IF *mGrayOutIf;
1220
1221 public:
1222   CIfrGrayOutIf () : CIfrObj (EFI_IFR_GRAY_OUT_IF_OP, (CHAR8 **)&mGrayOutIf),
1223                     CIfrOpHeader (EFI_IFR_GRAY_OUT_IF_OP, &mGrayOutIf->Header) {}
1224 };
1225
1226 class CIfrInconsistentIf : public CIfrObj, public CIfrOpHeader {
1227 private:
1228   EFI_IFR_INCONSISTENT_IF *mInconsistentIf;
1229
1230 public:
1231   CIfrInconsistentIf () : CIfrObj (EFI_IFR_INCONSISTENT_IF_OP, (CHAR8 **)&mInconsistentIf),
1232                         CIfrOpHeader (EFI_IFR_INCONSISTENT_IF_OP, &mInconsistentIf->Header) {
1233     mInconsistentIf->Error = EFI_STRING_ID_INVALID;
1234   }
1235
1236   VOID SetError (IN EFI_STRING_ID Error) {
1237     mInconsistentIf->Error = Error;
1238   }
1239 };
1240
1241 class CIfrNoSubmitIf : public CIfrObj, public CIfrOpHeader {
1242 private:
1243   EFI_IFR_NO_SUBMIT_IF *mNoSubmitIf;
1244
1245 public:
1246   CIfrNoSubmitIf () : CIfrObj (EFI_IFR_NO_SUBMIT_IF_OP, (CHAR8 **)&mNoSubmitIf),
1247                      CIfrOpHeader (EFI_IFR_NO_SUBMIT_IF_OP, &mNoSubmitIf->Header) {
1248     mNoSubmitIf->Error = EFI_STRING_ID_INVALID;
1249   }
1250
1251   VOID SetError (IN EFI_STRING_ID Error) {
1252     mNoSubmitIf->Error = Error;
1253   }
1254 };
1255
1256 class CIfrRefresh : public CIfrObj, public CIfrOpHeader {
1257 private:
1258   EFI_IFR_REFRESH *mRefresh;
1259
1260 public:
1261   CIfrRefresh () : CIfrObj (EFI_IFR_REFRESH_OP, (CHAR8 **)&mRefresh),
1262                   CIfrOpHeader (EFI_IFR_REFRESH_OP, &mRefresh->Header) {
1263     mRefresh->RefreshInterval = 0;
1264   }
1265
1266   VOID SetRefreshInterval (IN UINT8 RefreshInterval) {
1267     mRefresh->RefreshInterval = RefreshInterval;
1268   }
1269 };
1270
1271 class CIfrVarStoreDevice : public CIfrObj, public CIfrOpHeader {
1272 private:
1273   EFI_IFR_VARSTORE_DEVICE *mVarStoreDevice;
1274
1275 public:
1276   CIfrVarStoreDevice () : CIfrObj (EFI_IFR_VARSTORE_DEVICE_OP, (CHAR8 **)&mVarStoreDevice),
1277                           CIfrOpHeader (EFI_IFR_VARSTORE_DEVICE_OP, &mVarStoreDevice->Header) {
1278     mVarStoreDevice->DevicePath = EFI_STRING_ID_INVALID;
1279   }
1280
1281   VOID SetDevicePath (IN EFI_STRING_ID DevicePath) {
1282     mVarStoreDevice->DevicePath = DevicePath;
1283   }
1284 };
1285
1286 class CIfrOneOfOption : public CIfrObj, public CIfrOpHeader {
1287 private:
1288   EFI_IFR_ONE_OF_OPTION *mOneOfOption;
1289
1290 public:
1291   CIfrOneOfOption () : CIfrObj (EFI_IFR_ONE_OF_OPTION_OP, (CHAR8 **)&mOneOfOption),
1292                        CIfrOpHeader (EFI_IFR_ONE_OF_OPTION_OP, &mOneOfOption->Header) {
1293     mOneOfOption->Flags  = 0;
1294     mOneOfOption->Option = EFI_STRING_ID_INVALID;
1295     mOneOfOption->Type   = EFI_IFR_TYPE_OTHER;
1296     memset (&mOneOfOption->Value, 0, sizeof (mOneOfOption->Value));
1297   }
1298
1299   VOID SetOption (IN EFI_STRING_ID Option) {
1300     mOneOfOption->Option = Option;
1301   }
1302
1303   EFI_VFR_RETURN_CODE SetFlags (IN UINT8 LFlags) {
1304     if (_FLAG_TEST_AND_CLEAR (LFlags, EFI_IFR_OPTION_DEFAULT)) {
1305       mOneOfOption->Flags |= EFI_IFR_OPTION_DEFAULT;
1306     }
1307
1308     if (_FLAG_TEST_AND_CLEAR (LFlags, EFI_IFR_OPTION_DEFAULT_MFG)) {
1309       mOneOfOption->Flags |= EFI_IFR_OPTION_DEFAULT_MFG;
1310     }
1311
1312     if (_IS_EQUAL (LFlags, EFI_IFR_TYPE_NUM_SIZE_8)) {
1313       _FLAG_CLEAR (LFlags, EFI_IFR_TYPE_NUM_SIZE_8);
1314       mOneOfOption->Flags |= EFI_IFR_TYPE_NUM_SIZE_8;
1315     } else if (_IS_EQUAL (LFlags, EFI_IFR_TYPE_NUM_SIZE_16)) {
1316       _FLAG_CLEAR (LFlags, EFI_IFR_TYPE_NUM_SIZE_16);
1317       mOneOfOption->Flags |= EFI_IFR_TYPE_NUM_SIZE_16;
1318     } else if (_IS_EQUAL (LFlags, EFI_IFR_TYPE_NUM_SIZE_32)) {
1319       _FLAG_CLEAR (LFlags, EFI_IFR_TYPE_NUM_SIZE_32);
1320       mOneOfOption->Flags |= EFI_IFR_TYPE_NUM_SIZE_32;
1321     } else if (_IS_EQUAL (LFlags, EFI_IFR_TYPE_NUM_SIZE_64)) {
1322       _FLAG_CLEAR (LFlags, EFI_IFR_TYPE_NUM_SIZE_64);
1323       mOneOfOption->Flags |= EFI_IFR_TYPE_NUM_SIZE_64;
1324     } else if (_IS_EQUAL (LFlags, EFI_IFR_TYPE_BOOLEAN)) {
1325       _FLAG_CLEAR (LFlags, EFI_IFR_TYPE_BOOLEAN);
1326       mOneOfOption->Flags |= EFI_IFR_TYPE_BOOLEAN;
1327     } else if (_IS_EQUAL (LFlags, EFI_IFR_TYPE_TIME)) {
1328       _FLAG_CLEAR (LFlags, EFI_IFR_TYPE_TIME);
1329       mOneOfOption->Flags |= EFI_IFR_TYPE_TIME;
1330     } else if (_IS_EQUAL (LFlags, EFI_IFR_TYPE_DATE)) {
1331       _FLAG_CLEAR (LFlags, EFI_IFR_TYPE_DATE);
1332       mOneOfOption->Flags |= EFI_IFR_TYPE_DATE;
1333     } else if (_IS_EQUAL (LFlags, EFI_IFR_TYPE_STRING)) {
1334       _FLAG_CLEAR (LFlags, EFI_IFR_TYPE_STRING);
1335       mOneOfOption->Flags |= EFI_IFR_TYPE_STRING;
1336     } else if (_IS_EQUAL (LFlags, EFI_IFR_TYPE_OTHER)) {
1337       _FLAG_CLEAR (LFlags, EFI_IFR_TYPE_OTHER);
1338       mOneOfOption->Flags |= EFI_IFR_TYPE_OTHER;
1339     }
1340
1341     return _FLAGS_ZERO (LFlags) ? VFR_RETURN_SUCCESS : VFR_RETURN_FLAGS_UNSUPPORTED;
1342   }
1343
1344   VOID SetType (IN UINT8 Type) {
1345     mOneOfOption->Type = Type;
1346   }
1347
1348   VOID SetValue (IN EFI_IFR_TYPE_VALUE Value) {
1349     mOneOfOption->Value = Value;
1350   }
1351
1352   UINT8 GetFlags (VOID) {
1353     return mOneOfOption->Flags;
1354   }
1355 };
1356
1357 static EFI_GUID IfrTianoGuid     = EFI_IFR_TIANO_GUID;
1358 static EFI_GUID IfrFrameworkGuid = EFI_IFR_FRAMEWORK_GUID;
1359
1360 class CIfrClass : public CIfrObj, public CIfrOpHeader {
1361 private:
1362   EFI_IFR_GUID_CLASS *mClass;
1363
1364 public:
1365   CIfrClass () : CIfrObj (EFI_IFR_GUID_OP, (CHAR8 **)&mClass, sizeof (EFI_IFR_GUID_CLASS)),
1366                 CIfrOpHeader (EFI_IFR_GUID_OP, &mClass->Header, sizeof (EFI_IFR_GUID_CLASS)) {
1367     mClass->ExtendOpCode = EFI_IFR_EXTEND_OP_CLASS;
1368     mClass->Guid         = IfrTianoGuid;
1369     mClass->Class        = EFI_NON_DEVICE_CLASS;
1370   }
1371
1372   VOID SetClass (IN UINT16 Class) {
1373     mClass->Class        = Class;
1374   }
1375 };
1376
1377 class CIfrSubClass : public CIfrObj, public CIfrOpHeader {
1378 private:
1379   EFI_IFR_GUID_SUBCLASS *mSubClass;
1380
1381 public:
1382   CIfrSubClass () : CIfrObj (EFI_IFR_GUID_OP, (CHAR8 **)&mSubClass, sizeof (EFI_IFR_GUID_SUBCLASS)),
1383                     CIfrOpHeader (EFI_IFR_GUID_OP, &mSubClass->Header, sizeof (EFI_IFR_GUID_SUBCLASS)) {
1384     mSubClass->ExtendOpCode = EFI_IFR_EXTEND_OP_SUBCLASS;
1385     mSubClass->Guid         = IfrTianoGuid;
1386     mSubClass->SubClass     = EFI_SETUP_APPLICATION_SUBCLASS;
1387   }
1388
1389   VOID SetSubClass (IN UINT16 SubClass) {
1390     mSubClass->SubClass = SubClass;
1391   }
1392 };
1393
1394 class CIfrLabel : public CIfrObj, public CIfrOpHeader {
1395 private:
1396   EFI_IFR_GUID_LABEL *mLabel;
1397
1398 public:
1399   CIfrLabel () : CIfrObj (EFI_IFR_GUID_OP, (CHAR8 **)&mLabel, sizeof (EFI_IFR_GUID_LABEL)),
1400                 CIfrOpHeader (EFI_IFR_GUID_OP, &mLabel->Header, sizeof (EFI_IFR_GUID_LABEL)) {
1401     mLabel->ExtendOpCode = EFI_IFR_EXTEND_OP_LABEL;
1402     mLabel->Guid         = IfrTianoGuid;
1403   }
1404
1405   VOID SetNumber (IN UINT16 Number) {
1406     mLabel->Number = Number;
1407   }
1408 };
1409
1410 class CIfrBanner : public CIfrObj, public CIfrOpHeader {
1411 private:
1412   EFI_IFR_GUID_BANNER *mBanner;
1413
1414 public:
1415   CIfrBanner () : CIfrObj (EFI_IFR_GUID_OP, (CHAR8 **)&mBanner, sizeof (EFI_IFR_GUID_BANNER)),
1416                   CIfrOpHeader (EFI_IFR_GUID_OP, &mBanner->Header, sizeof (EFI_IFR_GUID_BANNER)) {
1417     mBanner->ExtendOpCode = EFI_IFR_EXTEND_OP_BANNER;
1418     mBanner->Guid         = IfrTianoGuid;
1419   }
1420
1421   VOID SetTitle (IN EFI_STRING_ID StringId) {
1422     mBanner->Title = StringId;
1423   }
1424
1425   VOID SetLine (IN UINT16 Line) {
1426     mBanner->LineNumber = Line;
1427   }
1428
1429   VOID SetAlign (IN UINT8 Align) {
1430     mBanner->Alignment = Align;
1431   }
1432 };
1433
1434 class CIfrOptionKey : public CIfrObj, public CIfrOpHeader {
1435 private:
1436   EFI_IFR_GUID_OPTIONKEY *mOptionKey;
1437
1438 public:
1439   CIfrOptionKey (
1440     IN EFI_QUESTION_ID QuestionId,
1441     IN EFI_IFR_TYPE_VALUE &OptionValue,
1442     IN EFI_QUESTION_ID KeyValue
1443   ) : CIfrObj (EFI_IFR_GUID_OP, (CHAR8 **)&mOptionKey, sizeof (EFI_IFR_GUID_OPTIONKEY)),
1444       CIfrOpHeader (EFI_IFR_GUID_OP, &mOptionKey->Header, sizeof (EFI_IFR_GUID_OPTIONKEY)) {
1445     mOptionKey->ExtendOpCode = EFI_IFR_EXTEND_OP_OPTIONKEY;
1446     mOptionKey->Guid         = IfrFrameworkGuid;
1447     mOptionKey->QuestionId   = QuestionId;
1448     mOptionKey->OptionValue  = OptionValue;
1449     mOptionKey->KeyValue     = KeyValue;
1450   }
1451 };
1452
1453 class CIfrVarEqName : public CIfrObj, public CIfrOpHeader {
1454 private:
1455   EFI_IFR_GUID_VAREQNAME *mVarEqName;
1456
1457 public:
1458   CIfrVarEqName (
1459     IN EFI_QUESTION_ID QuestionId,
1460     IN EFI_STRING_ID   NameId
1461   ) : CIfrObj (EFI_IFR_GUID_OP, (CHAR8 **)&mVarEqName, sizeof (EFI_IFR_GUID_VAREQNAME)),
1462       CIfrOpHeader (EFI_IFR_GUID_OP, &mVarEqName->Header, sizeof (EFI_IFR_GUID_VAREQNAME)) {
1463     mVarEqName->ExtendOpCode = EFI_IFR_EXTEND_OP_VAREQNAME;
1464     mVarEqName->Guid         = IfrFrameworkGuid;
1465     mVarEqName->QuestionId   = QuestionId;
1466     mVarEqName->NameId       = NameId;
1467   }
1468 };
1469
1470 class CIfrTimeout : public CIfrObj, public CIfrOpHeader {
1471 private:
1472   EFI_IFR_GUID_TIMEOUT *mTimeout;
1473
1474 public:
1475   CIfrTimeout (IN UINT16 Timeout = 0) : CIfrObj (EFI_IFR_GUID_OP, (CHAR8 **)&mTimeout, sizeof (EFI_IFR_GUID_TIMEOUT)),
1476                                         CIfrOpHeader (EFI_IFR_GUID_OP, &mTimeout->Header, sizeof (EFI_IFR_GUID_TIMEOUT)) {
1477     mTimeout->ExtendOpCode = EFI_IFR_EXTEND_OP_TIMEOUT;
1478     mTimeout->Guid         = IfrTianoGuid;
1479     mTimeout->TimeOut      = Timeout;
1480   }
1481
1482   VOID SetTimeout (IN UINT16 Timeout) {
1483     mTimeout->TimeOut = Timeout;
1484   }
1485 };
1486
1487 class CIfrDup : public CIfrObj, public CIfrOpHeader {
1488 private:
1489   EFI_IFR_DUP *mDup;
1490
1491 public:
1492   CIfrDup (
1493   IN UINT32 LineNo
1494   ) : CIfrObj (EFI_IFR_DUP_OP, (CHAR8 **)&mDup),
1495       CIfrOpHeader (EFI_IFR_DUP_OP, &mDup->Header) {
1496     SetLineNo (LineNo);
1497   }
1498 };
1499
1500 class CIfrEqIdId : public CIfrObj, public CIfrOpHeader {
1501 private:
1502   EFI_IFR_EQ_ID_ID   *mEqIdId;
1503
1504 public:
1505   CIfrEqIdId (
1506   IN UINT32 LineNo
1507   ) : CIfrObj (EFI_IFR_EQ_ID_ID_OP, (CHAR8 **)&mEqIdId),
1508                  CIfrOpHeader (EFI_IFR_EQ_ID_ID_OP, &mEqIdId->Header) {
1509     SetLineNo (LineNo);
1510     mEqIdId->QuestionId1 = EFI_QUESTION_ID_INVALID;
1511     mEqIdId->QuestionId2 = EFI_QUESTION_ID_INVALID;
1512   }
1513
1514   VOID SetQuestionId1 (
1515   IN EFI_QUESTION_ID QuestionId,
1516   IN CHAR8            *VarIdStr,
1517   IN UINT32          LineNo
1518   ) {
1519     if (QuestionId != EFI_QUESTION_ID_INVALID) {
1520       mEqIdId->QuestionId1 = QuestionId;
1521     } else {
1522       gCFormPkg.AssignPending (VarIdStr, (VOID *)(&mEqIdId->QuestionId1), sizeof (EFI_QUESTION_ID), LineNo, NO_QST_REFED);
1523     }
1524   }
1525
1526   VOID SetQuestionId2 (
1527   IN EFI_QUESTION_ID QuestionId,
1528   IN CHAR8            *VarIdStr,
1529   IN UINT32          LineNo
1530   ) {
1531     if (QuestionId != EFI_QUESTION_ID_INVALID) {
1532       mEqIdId->QuestionId2 = QuestionId;
1533     } else {
1534       gCFormPkg.AssignPending (VarIdStr, (VOID *)(&mEqIdId->QuestionId2), sizeof (EFI_QUESTION_ID), LineNo, NO_QST_REFED);
1535     }
1536   }
1537 };
1538
1539 class CIfrEqIdVal : public CIfrObj, public CIfrOpHeader {
1540 private:
1541   EFI_IFR_EQ_ID_VAL *mEqIdVal;
1542
1543 public:
1544   CIfrEqIdVal (
1545   IN UINT32 LineNo
1546   ) : CIfrObj (EFI_IFR_EQ_ID_VAL_OP, (CHAR8 **)&mEqIdVal),
1547       CIfrOpHeader (EFI_IFR_EQ_ID_VAL_OP, &mEqIdVal->Header) {
1548     SetLineNo (LineNo);
1549     mEqIdVal->QuestionId = EFI_QUESTION_ID_INVALID;
1550   }
1551
1552   VOID SetQuestionId (
1553   IN EFI_QUESTION_ID QuestionId,
1554   IN CHAR8           *VarIdStr,
1555   IN UINT32          LineNo
1556   ) {
1557     if (QuestionId != EFI_QUESTION_ID_INVALID) {
1558       mEqIdVal->QuestionId = QuestionId;
1559     } else {
1560       gCFormPkg.AssignPending (VarIdStr, (VOID *)(&mEqIdVal->QuestionId), sizeof (EFI_QUESTION_ID), LineNo, NO_QST_REFED);
1561     }
1562   }
1563
1564   VOID SetValue (IN UINT16 Value) {
1565     mEqIdVal->Value = Value;
1566   }
1567 };
1568
1569 class CIfrEqIdList : public CIfrObj, public CIfrOpHeader {
1570 private:
1571   EFI_IFR_EQ_ID_LIST *mEqIdVList;
1572
1573 public:
1574   CIfrEqIdList (
1575   IN UINT32 LineNo
1576   ) : CIfrObj (EFI_IFR_EQ_ID_LIST_OP, (CHAR8 **)&mEqIdVList, sizeof (EFI_IFR_EQ_ID_LIST), TRUE),
1577                    CIfrOpHeader (EFI_IFR_EQ_ID_LIST_OP, &mEqIdVList->Header) {
1578     SetLineNo (LineNo);
1579     mEqIdVList->QuestionId   = EFI_QUESTION_ID_INVALID;
1580     mEqIdVList->ListLength   = 0;
1581     mEqIdVList->ValueList[0] = 0;
1582   }
1583
1584   VOID UpdateIfrBuffer (
1585   ) {
1586     _EMIT_PENDING_OBJ();
1587     mEqIdVList = (EFI_IFR_EQ_ID_LIST *) GetObjBinAddr();
1588     UpdateHeader (&mEqIdVList->Header);
1589   }
1590
1591   VOID SetQuestionId (
1592   IN EFI_QUESTION_ID QuestionId,
1593   IN CHAR8           *VarIdStr,
1594   IN UINT32          LineNo
1595   ) {
1596     if (QuestionId != EFI_QUESTION_ID_INVALID) {
1597       mEqIdVList->QuestionId = QuestionId;
1598     } else {
1599       gCFormPkg.AssignPending (VarIdStr, (VOID *)(&mEqIdVList->QuestionId), sizeof (EFI_QUESTION_ID), LineNo, NO_QST_REFED);
1600     }
1601   }
1602
1603   VOID SetListLength (IN UINT16 ListLength) {
1604     mEqIdVList->ListLength = ListLength;
1605   }
1606
1607   VOID SetValueList (IN UINT16 Index, IN UINT16 Value) {
1608     if (Index == 0) {
1609       mEqIdVList->ValueList[0] = Value;
1610       return;
1611     }
1612
1613     if (ExpendObjBin (sizeof (UINT16)) ==TRUE) {
1614       IncLength (sizeof (UINT16));
1615       mEqIdVList->ValueList[Index] = Value;
1616     }
1617   }
1618 };
1619
1620 class CIfrQuestionRef1 : public CIfrObj, public CIfrOpHeader {
1621 private:
1622   EFI_IFR_QUESTION_REF1 *mQuestionRef1;
1623
1624 public:
1625   CIfrQuestionRef1 (
1626   IN UINT32 LineNo
1627   ) : CIfrObj (EFI_IFR_QUESTION_REF1_OP, (CHAR8 **)&mQuestionRef1),
1628       CIfrOpHeader (EFI_IFR_QUESTION_REF1_OP, &mQuestionRef1->Header) {
1629     SetLineNo (LineNo);
1630     mQuestionRef1->QuestionId = EFI_QUESTION_ID_INVALID;
1631   }
1632
1633   VOID SetQuestionId (
1634   IN EFI_QUESTION_ID QuestionId,
1635   IN CHAR8           *VarIdStr,
1636   IN UINT32          LineNo
1637   ) {
1638     if (QuestionId != EFI_QUESTION_ID_INVALID) {
1639       mQuestionRef1->QuestionId = QuestionId;
1640     } else {
1641       gCFormPkg.AssignPending (VarIdStr, (VOID *)(&mQuestionRef1->QuestionId), sizeof (EFI_QUESTION_ID), LineNo, NO_QST_REFED);
1642     }
1643   }
1644 };
1645
1646 class CIfrQuestionRef2 : public CIfrObj, public CIfrOpHeader {
1647 private:
1648   EFI_IFR_QUESTION_REF2 *mQuestionRef2;
1649
1650 public:
1651   CIfrQuestionRef2 (
1652   IN UINT32 LineNo
1653   ) : CIfrObj (EFI_IFR_QUESTION_REF2_OP, (CHAR8 **)&mQuestionRef2),
1654       CIfrOpHeader (EFI_IFR_QUESTION_REF2_OP, &mQuestionRef2->Header) {
1655     SetLineNo (LineNo);
1656   }
1657 };
1658
1659 class CIfrQuestionRef3 : public CIfrObj, public CIfrOpHeader {
1660 private:
1661   EFI_IFR_QUESTION_REF3 *mQuestionRef3;
1662
1663 public:
1664   CIfrQuestionRef3 (
1665   IN UINT32 LineNo
1666   ) : CIfrObj (EFI_IFR_QUESTION_REF3_OP, (CHAR8 **)&mQuestionRef3),
1667       CIfrOpHeader (EFI_IFR_QUESTION_REF3_OP, &mQuestionRef3->Header) {
1668     SetLineNo (LineNo);
1669   }
1670 };
1671
1672 class CIfrQuestionRef3_2 : public CIfrObj, public CIfrOpHeader {
1673 private:
1674   EFI_IFR_QUESTION_REF3_2 *mQuestionRef3_2;
1675
1676 public:
1677   CIfrQuestionRef3_2 (
1678   IN UINT32 LineNo
1679   ) : CIfrObj (EFI_IFR_QUESTION_REF3_OP, (CHAR8 **)&mQuestionRef3_2, sizeof (EFI_IFR_QUESTION_REF3_2)),
1680       CIfrOpHeader (EFI_IFR_QUESTION_REF3_OP, &mQuestionRef3_2->Header, sizeof (EFI_IFR_QUESTION_REF3_2)) {
1681     SetLineNo (LineNo);
1682     mQuestionRef3_2->DevicePath = EFI_STRING_ID_INVALID;
1683   }
1684
1685   VOID SetDevicePath (IN EFI_STRING_ID DevicePath) {
1686     mQuestionRef3_2->DevicePath = DevicePath;
1687   }
1688 };
1689
1690 class CIfrQuestionRef3_3 : public CIfrObj, public CIfrOpHeader {
1691 private:
1692   EFI_IFR_QUESTION_REF3_3 *mQuestionRef3_3;
1693
1694 public:
1695   CIfrQuestionRef3_3 (
1696   IN UINT32 LineNo
1697   ) : CIfrObj (EFI_IFR_QUESTION_REF3_OP, (CHAR8 **)&mQuestionRef3_3, sizeof (EFI_IFR_QUESTION_REF3_3)),
1698       CIfrOpHeader (EFI_IFR_QUESTION_REF3_OP, &mQuestionRef3_3->Header, sizeof (EFI_IFR_QUESTION_REF3_3)) {
1699     SetLineNo (LineNo);
1700     mQuestionRef3_3->DevicePath = EFI_STRING_ID_INVALID;
1701     memset (&mQuestionRef3_3->Guid, 0, sizeof (EFI_GUID));
1702   }
1703
1704   VOID SetDevicePath (IN EFI_STRING_ID DevicePath) {
1705     mQuestionRef3_3->DevicePath = DevicePath;
1706   }
1707
1708   VOID SetGuid (IN EFI_GUID *Guid) {
1709     mQuestionRef3_3->Guid = *Guid;
1710   }
1711 };
1712
1713 class CIfrRuleRef : public CIfrObj, public CIfrOpHeader {
1714 private:
1715   EFI_IFR_RULE_REF *mRuleRef;
1716
1717 public:
1718   CIfrRuleRef (
1719   IN UINT32 LineNo
1720   ) : CIfrObj (EFI_IFR_RULE_REF_OP, (CHAR8 **)&mRuleRef),
1721       CIfrOpHeader (EFI_IFR_RULE_REF_OP, &mRuleRef->Header) {
1722     SetLineNo (LineNo);
1723     mRuleRef->RuleId = EFI_RULE_ID_INVALID;
1724   }
1725
1726   VOID SetRuleId (IN UINT8 RuleId) {
1727     mRuleRef->RuleId = RuleId;
1728   }
1729 };
1730
1731 class CIfrStringRef1 : public CIfrObj, public CIfrOpHeader {
1732 private:
1733   EFI_IFR_STRING_REF1 *mStringRef1;
1734
1735 public:
1736   CIfrStringRef1 (
1737   IN UINT32 LineNo
1738   ) : CIfrObj (EFI_IFR_STRING_REF1_OP, (CHAR8 **)&mStringRef1),
1739       CIfrOpHeader (EFI_IFR_STRING_REF1_OP, &mStringRef1->Header) {
1740     SetLineNo (LineNo);
1741     mStringRef1->StringId = EFI_STRING_ID_INVALID;
1742   }
1743
1744   VOID SetStringId (IN EFI_STRING_ID StringId) {
1745     mStringRef1->StringId = StringId;
1746   }
1747 };
1748
1749 class CIfrStringRef2 : public CIfrObj, public CIfrOpHeader {
1750 private:
1751   EFI_IFR_STRING_REF2 *mStringRef2;
1752
1753 public:
1754   CIfrStringRef2 (
1755   IN UINT32 LineNo
1756   ) : CIfrObj (EFI_IFR_STRING_REF2_OP, (CHAR8 **)&mStringRef2),
1757       CIfrOpHeader (EFI_IFR_STRING_REF2_OP, &mStringRef2->Header) {
1758     SetLineNo (LineNo);
1759   }
1760 };
1761
1762 class CIfrThis : public CIfrObj, public CIfrOpHeader {
1763 private:
1764   EFI_IFR_THIS *mThis;
1765
1766 public:
1767   CIfrThis (
1768   IN UINT32 LineNo
1769   ) : CIfrObj (EFI_IFR_THIS_OP, (CHAR8 **)&mThis),
1770       CIfrOpHeader (EFI_IFR_THIS_OP, &mThis->Header) {
1771     SetLineNo (LineNo);
1772   }
1773 };
1774
1775 class CIfrUint8 : public CIfrObj, public CIfrOpHeader {
1776 private:
1777   EFI_IFR_UINT8 *mUint8;
1778
1779 public:
1780   CIfrUint8 (
1781   IN UINT32 LineNo
1782   ) : CIfrObj (EFI_IFR_UINT8_OP, (CHAR8 **)&mUint8),
1783       CIfrOpHeader (EFI_IFR_UINT8_OP, &mUint8->Header) {
1784     SetLineNo (LineNo);
1785   }
1786
1787   VOID SetValue (IN UINT8 Value) {
1788     mUint8->Value = Value;
1789   }
1790 };
1791
1792 class CIfrUint16 : public CIfrObj, public CIfrOpHeader {
1793 private:
1794   EFI_IFR_UINT16 *mUint16;
1795
1796 public:
1797   CIfrUint16 (
1798   IN UINT32 LineNo
1799   ) : CIfrObj (EFI_IFR_UINT16_OP, (CHAR8 **)&mUint16),
1800       CIfrOpHeader (EFI_IFR_UINT16_OP, &mUint16->Header) {
1801     SetLineNo (LineNo);
1802   }
1803
1804   VOID SetValue (IN UINT16 Value) {
1805     mUint16->Value = Value;
1806   }
1807 };
1808
1809 class CIfrUint32 : public CIfrObj, public CIfrOpHeader {
1810 private:
1811   EFI_IFR_UINT32 *mUint32;
1812
1813 public:
1814   CIfrUint32 (
1815   IN UINT32 LineNo
1816   ) : CIfrObj (EFI_IFR_UINT32_OP, (CHAR8 **)&mUint32),
1817       CIfrOpHeader (EFI_IFR_UINT32_OP, &mUint32->Header) {
1818     SetLineNo (LineNo);
1819   }
1820
1821   VOID SetValue (IN UINT32 Value) {
1822     mUint32->Value = Value;
1823   }
1824 };
1825
1826 class CIfrUint64 : public CIfrObj, public CIfrOpHeader {
1827 private:
1828   EFI_IFR_UINT64 *mUint64;
1829
1830 public:
1831   CIfrUint64 (
1832   IN UINT32 LineNo
1833   ) : CIfrObj (EFI_IFR_UINT64_OP, (CHAR8 **)&mUint64),
1834       CIfrOpHeader (EFI_IFR_UINT64_OP, &mUint64->Header) {
1835     SetLineNo (LineNo);
1836   }
1837
1838   VOID SetValue (IN UINT64 Value) {
1839     mUint64->Value = Value;
1840   }
1841 };
1842
1843 class CIfrTrue : public CIfrObj, public CIfrOpHeader {
1844 private:
1845   EFI_IFR_TRUE *mTrue;
1846
1847 public:
1848   CIfrTrue (
1849   IN UINT32 LineNo
1850   ) : CIfrObj (EFI_IFR_TRUE_OP, (CHAR8 **)&mTrue),
1851       CIfrOpHeader (EFI_IFR_TRUE_OP, &mTrue->Header) {
1852     SetLineNo (LineNo);
1853   }
1854 };
1855
1856 class CIfrFalse : public CIfrObj, public CIfrOpHeader {
1857 private:
1858   EFI_IFR_FALSE *mFalse;
1859
1860 public:
1861   CIfrFalse (
1862   IN UINT32 LineNo
1863   ) : CIfrObj (EFI_IFR_FALSE_OP, (CHAR8 **)&mFalse),
1864       CIfrOpHeader (EFI_IFR_FALSE_OP, &mFalse->Header) {
1865     SetLineNo (LineNo);
1866   }
1867 };
1868
1869 class CIfrOne : public CIfrObj, public CIfrOpHeader {
1870 private:
1871   EFI_IFR_ONE *mOne;
1872
1873 public:
1874   CIfrOne (
1875   IN UINT32 LineNo
1876   ) : CIfrObj (EFI_IFR_ONE_OP, (CHAR8 **)&mOne),
1877       CIfrOpHeader (EFI_IFR_ONE_OP, &mOne->Header) {
1878     SetLineNo (LineNo);
1879   }
1880 };
1881
1882 class CIfrOnes : public CIfrObj, public CIfrOpHeader {
1883 private:
1884   EFI_IFR_ONES *mOnes;
1885
1886 public:
1887   CIfrOnes (
1888   IN UINT32 LineNo
1889   ) : CIfrObj (EFI_IFR_ONES_OP, (CHAR8 **)&mOnes),
1890       CIfrOpHeader (EFI_IFR_ONES_OP, &mOnes->Header) {
1891     SetLineNo (LineNo);
1892   }
1893 };
1894
1895 class CIfrZero : public CIfrObj, public CIfrOpHeader {
1896 private:
1897   EFI_IFR_ZERO *mZero;
1898
1899 public:
1900   CIfrZero (
1901   IN UINT32 LineNo
1902   ) : CIfrObj (EFI_IFR_ZERO_OP, (CHAR8 **)&mZero),
1903       CIfrOpHeader (EFI_IFR_ZERO_OP, &mZero->Header) {
1904     SetLineNo (LineNo);
1905   }
1906 };
1907
1908 class CIfrUndefined : public CIfrObj, public CIfrOpHeader {
1909 private:
1910   EFI_IFR_UNDEFINED *mUndefined;
1911
1912 public:
1913   CIfrUndefined (
1914   IN UINT32 LineNo
1915   ) : CIfrObj (EFI_IFR_UNDEFINED_OP, (CHAR8 **)&mUndefined),
1916       CIfrOpHeader (EFI_IFR_UNDEFINED_OP, &mUndefined->Header) {
1917     SetLineNo (LineNo);
1918   }
1919 };
1920
1921 class CIfrVersion : public CIfrObj, public CIfrOpHeader {
1922 private:
1923   EFI_IFR_VERSION *mVersion;
1924
1925 public:
1926   CIfrVersion (
1927   IN UINT32 LineNo
1928   ) : CIfrObj (EFI_IFR_VERSION_OP, (CHAR8 **)&mVersion),
1929       CIfrOpHeader (EFI_IFR_VERSION_OP, &mVersion->Header) {
1930     SetLineNo (LineNo);
1931   }
1932 };
1933
1934 class CIfrLength : public CIfrObj, public CIfrOpHeader {
1935 private:
1936   EFI_IFR_LENGTH *mLength;
1937
1938 public:
1939   CIfrLength (
1940   IN UINT32 LineNo
1941   ) : CIfrObj (EFI_IFR_LENGTH_OP, (CHAR8 **)&mLength),
1942       CIfrOpHeader (EFI_IFR_LENGTH_OP, &mLength->Header) {
1943     SetLineNo (LineNo);
1944   }
1945 };
1946
1947 class CIfrNot : public CIfrObj, public CIfrOpHeader {
1948 private:
1949   EFI_IFR_NOT *mNot;
1950
1951 public:
1952   CIfrNot (
1953   IN UINT32 LineNo
1954   ) : CIfrObj (EFI_IFR_NOT_OP, (CHAR8 **)&mNot),
1955       CIfrOpHeader (EFI_IFR_NOT_OP, &mNot->Header) {
1956     SetLineNo (LineNo);
1957   }
1958 };
1959
1960 class CIfrBitWiseNot : public CIfrObj, public CIfrOpHeader {
1961 private:
1962   EFI_IFR_BITWISE_NOT *mBitWise;
1963
1964 public:
1965   CIfrBitWiseNot (
1966   IN UINT32 LineNo
1967   ) : CIfrObj (EFI_IFR_BITWISE_NOT_OP, (CHAR8 **)&mBitWise),
1968       CIfrOpHeader (EFI_IFR_BITWISE_NOT_OP, &mBitWise->Header) {
1969     SetLineNo (LineNo);
1970   }
1971 };
1972
1973 class CIfrToBoolean : public CIfrObj, public CIfrOpHeader {
1974 private:
1975   EFI_IFR_TO_BOOLEAN *mToBoolean;
1976
1977 public:
1978   CIfrToBoolean (
1979   IN UINT32 LineNo
1980   ) : CIfrObj (EFI_IFR_TO_BOOLEAN_OP, (CHAR8 **)&mToBoolean),
1981       CIfrOpHeader (EFI_IFR_TO_BOOLEAN_OP, &mToBoolean->Header) {
1982     SetLineNo (LineNo);
1983   }
1984 };
1985
1986 class CIfrToString : public CIfrObj, public CIfrOpHeader {
1987 private:
1988   EFI_IFR_TO_STRING *mToString;
1989
1990 public:
1991   CIfrToString (
1992   IN UINT32 LineNo
1993   ) : CIfrObj (EFI_IFR_TO_STRING_OP, (CHAR8 **)&mToString),
1994       CIfrOpHeader (EFI_IFR_TO_STRING_OP, &mToString->Header) {
1995     SetLineNo (LineNo);
1996   }
1997
1998   VOID SetFormat (IN UINT8 Format) {
1999     mToString->Format = Format;
2000   }
2001 };
2002
2003 class CIfrToUint : public CIfrObj, public CIfrOpHeader {
2004 private:
2005   EFI_IFR_TO_UINT *mToUint;
2006
2007 public:
2008   CIfrToUint (
2009   IN UINT32 LineNo
2010   ) : CIfrObj (EFI_IFR_TO_UINT_OP, (CHAR8 **)&mToUint),
2011       CIfrOpHeader (EFI_IFR_TO_UINT_OP, &mToUint->Header) {
2012     SetLineNo (LineNo);
2013   }
2014 };
2015
2016 class CIfrToUpper : public CIfrObj, public CIfrOpHeader {
2017 private:
2018   EFI_IFR_TO_UPPER *mToUpper;
2019
2020 public:
2021   CIfrToUpper (
2022   IN UINT32 LineNo
2023   ) : CIfrObj (EFI_IFR_TO_UPPER_OP, (CHAR8 **)&mToUpper),
2024       CIfrOpHeader (EFI_IFR_TO_UPPER_OP, &mToUpper->Header) {
2025     SetLineNo (LineNo);
2026   }
2027 };
2028
2029 class CIfrToLower : public CIfrObj, public CIfrOpHeader {
2030 private:
2031   EFI_IFR_TO_LOWER *mToLower;
2032
2033 public:
2034   CIfrToLower (
2035   IN UINT32 LineNo
2036   ) : CIfrObj (EFI_IFR_TO_LOWER_OP, (CHAR8 **)&mToLower),
2037       CIfrOpHeader (EFI_IFR_TO_LOWER_OP, &mToLower->Header) {
2038     SetLineNo (LineNo);
2039   }
2040 };
2041
2042 class CIfrAdd : public CIfrObj, public CIfrOpHeader {
2043 private:
2044   EFI_IFR_ADD *mAdd;
2045
2046 public:
2047   CIfrAdd (
2048   IN UINT32 LineNo
2049   ) : CIfrObj (EFI_IFR_ADD_OP, (CHAR8 **)&mAdd),
2050       CIfrOpHeader (EFI_IFR_ADD_OP, &mAdd->Header) {
2051     SetLineNo (LineNo);
2052   }
2053 };
2054
2055 class CIfrBitWiseAnd : public CIfrObj, public CIfrOpHeader {
2056 private:
2057   EFI_IFR_BITWISE_AND *mBitWiseAnd;
2058
2059 public:
2060   CIfrBitWiseAnd (
2061   IN UINT32 LineNo
2062   ) : CIfrObj (EFI_IFR_BITWISE_AND_OP, (CHAR8 **)&mBitWiseAnd),
2063       CIfrOpHeader (EFI_IFR_BITWISE_AND_OP, &mBitWiseAnd->Header) {
2064     SetLineNo(LineNo);
2065   }
2066 };
2067
2068 class CIfrBitWiseOr : public CIfrObj, public CIfrOpHeader {
2069 private:
2070   EFI_IFR_BITWISE_OR *mBitWiseOr;
2071
2072 public:
2073   CIfrBitWiseOr (
2074   IN UINT32 LineNo
2075   ) : CIfrObj (EFI_IFR_BITWISE_OR_OP, (CHAR8 **)&mBitWiseOr),
2076       CIfrOpHeader (EFI_IFR_BITWISE_OR_OP, &mBitWiseOr->Header) {
2077     SetLineNo (LineNo);
2078   }
2079 };
2080
2081 class CIfrAnd : public CIfrObj, public CIfrOpHeader {
2082 private:
2083   EFI_IFR_AND *mAnd;
2084
2085 public:
2086   CIfrAnd (
2087   IN UINT32 LineNo
2088   ) : CIfrObj (EFI_IFR_AND_OP, (CHAR8 **)&mAnd),
2089       CIfrOpHeader (EFI_IFR_AND_OP, &mAnd->Header) {
2090     SetLineNo (LineNo);
2091   }
2092 };
2093
2094 class CIfrCatenate : public CIfrObj, public CIfrOpHeader {
2095 private:
2096   EFI_IFR_CATENATE *mCatenate;
2097
2098 public:
2099   CIfrCatenate (
2100   IN UINT32 LineNo
2101   ) : CIfrObj (EFI_IFR_CATENATE_OP, (CHAR8 **)&mCatenate),
2102       CIfrOpHeader (EFI_IFR_CATENATE_OP, &mCatenate->Header) {
2103     SetLineNo (LineNo);
2104   }
2105 };
2106
2107 class CIfrDivide : public CIfrObj, public CIfrOpHeader {
2108 private:
2109   EFI_IFR_DIVIDE *mDivide;
2110
2111 public:
2112   CIfrDivide (
2113   IN UINT32 LineNo
2114   ) : CIfrObj (EFI_IFR_DIVIDE_OP, (CHAR8 **)&mDivide),
2115       CIfrOpHeader (EFI_IFR_DIVIDE_OP, &mDivide->Header) {
2116     SetLineNo (LineNo);
2117   }
2118 };
2119
2120 class CIfrEqual : public CIfrObj, public CIfrOpHeader {
2121 private:
2122   EFI_IFR_EQUAL *mEqual;
2123
2124 public:
2125   CIfrEqual (
2126   IN UINT32 LineNo
2127   ) : CIfrObj (EFI_IFR_EQUAL_OP, (CHAR8 **)&mEqual),
2128       CIfrOpHeader (EFI_IFR_EQUAL_OP, &mEqual->Header) {
2129     SetLineNo (LineNo);
2130   }
2131 };
2132
2133 class CIfrGreaterEqual : public CIfrObj, public CIfrOpHeader {
2134 private:
2135   EFI_IFR_GREATER_EQUAL *mGreaterEqual;
2136
2137 public:
2138   CIfrGreaterEqual (
2139   IN UINT32 LineNo
2140   ) : CIfrObj (EFI_IFR_GREATER_EQUAL_OP, (CHAR8 **)&mGreaterEqual),
2141       CIfrOpHeader (EFI_IFR_GREATER_EQUAL_OP, &mGreaterEqual->Header) {
2142     SetLineNo (LineNo);
2143   }
2144 };
2145
2146 class CIfrGreaterThan : public CIfrObj, public CIfrOpHeader {
2147 private:
2148   EFI_IFR_GREATER_THAN *mGreaterThan;
2149
2150 public:
2151   CIfrGreaterThan (
2152   IN UINT32 LineNo
2153   ) : CIfrObj (EFI_IFR_GREATER_THAN_OP, (CHAR8 **)&mGreaterThan),
2154       CIfrOpHeader (EFI_IFR_GREATER_THAN_OP, &mGreaterThan->Header) {
2155     SetLineNo (LineNo);
2156   }
2157 };
2158
2159 class CIfrLessEqual : public CIfrObj, public CIfrOpHeader {
2160 private:
2161   EFI_IFR_LESS_EQUAL *mLessEqual;
2162
2163 public:
2164   CIfrLessEqual (
2165   IN UINT32 LineNo
2166   ) : CIfrObj (EFI_IFR_LESS_EQUAL_OP, (CHAR8 **)&mLessEqual),
2167       CIfrOpHeader (EFI_IFR_LESS_EQUAL_OP, &mLessEqual->Header) {
2168     SetLineNo (LineNo);
2169   }
2170 };
2171
2172 class CIfrLessThan : public CIfrObj, public CIfrOpHeader {
2173 private:
2174   EFI_IFR_LESS_THAN *mLessThan;
2175
2176 public:
2177   CIfrLessThan (
2178   IN UINT32 LineNo
2179   ) : CIfrObj (EFI_IFR_LESS_THAN_OP, (CHAR8 **)&mLessThan),
2180       CIfrOpHeader (EFI_IFR_LESS_THAN_OP, &mLessThan->Header) {
2181     SetLineNo (LineNo);
2182   }
2183 };
2184
2185 class CIfrMatch : public CIfrObj, public CIfrOpHeader {
2186 private:
2187   EFI_IFR_MATCH *mMatch;
2188
2189 public:
2190   CIfrMatch (
2191   IN UINT32 LineNo
2192   ) : CIfrObj (EFI_IFR_MATCH_OP, (CHAR8 **)&mMatch),
2193       CIfrOpHeader (EFI_IFR_MATCH_OP, &mMatch->Header) {
2194     SetLineNo (LineNo);
2195   }
2196 };
2197
2198 class CIfrMultiply : public CIfrObj, public CIfrOpHeader {
2199 private:
2200   EFI_IFR_MULTIPLY *mMultiply;
2201
2202 public:
2203   CIfrMultiply (
2204   IN UINT32 LineNo
2205   ) : CIfrObj (EFI_IFR_MULTIPLY_OP, (CHAR8 **)&mMultiply),
2206       CIfrOpHeader (EFI_IFR_MULTIPLY_OP, &mMultiply->Header) {
2207     SetLineNo (LineNo);
2208   }
2209 };
2210
2211 class CIfrModulo : public CIfrObj, public CIfrOpHeader {
2212 private:
2213   EFI_IFR_MODULO *mModulo;
2214
2215 public:
2216   CIfrModulo (
2217   IN UINT32 LineNo
2218   ) : CIfrObj (EFI_IFR_MODULO_OP, (CHAR8 **)&mModulo),
2219       CIfrOpHeader (EFI_IFR_MODULO_OP, &mModulo->Header) {
2220     SetLineNo (LineNo);
2221   }
2222 };
2223
2224 class CIfrNotEqual : public CIfrObj, public CIfrOpHeader {
2225 private:
2226   EFI_IFR_NOT_EQUAL *mNotEqual;
2227
2228 public:
2229   CIfrNotEqual (
2230   IN UINT32 LineNo
2231   ) : CIfrObj (EFI_IFR_NOT_EQUAL_OP, (CHAR8 **)&mNotEqual),
2232       CIfrOpHeader (EFI_IFR_NOT_EQUAL_OP, &mNotEqual->Header) {
2233     SetLineNo (LineNo);
2234   }
2235 };
2236
2237 class CIfrOr : public CIfrObj, public CIfrOpHeader {
2238 private:
2239   EFI_IFR_OR *mOr;
2240
2241 public:
2242   CIfrOr (
2243   IN UINT32 LineNo
2244   ) : CIfrObj (EFI_IFR_OR_OP, (CHAR8 **)&mOr),
2245       CIfrOpHeader (EFI_IFR_OR_OP, &mOr->Header) {
2246     SetLineNo (LineNo);
2247   }
2248 };
2249
2250 class CIfrShiftLeft : public CIfrObj, public CIfrOpHeader {
2251 private:
2252   EFI_IFR_SHIFT_LEFT *mShiftLeft;
2253
2254 public:
2255   CIfrShiftLeft (
2256   IN UINT32 LineNo
2257   ) : CIfrObj (EFI_IFR_SHIFT_LEFT_OP, (CHAR8 **)&mShiftLeft),
2258       CIfrOpHeader (EFI_IFR_SHIFT_LEFT_OP, &mShiftLeft->Header) {
2259     SetLineNo (LineNo);
2260   }
2261 };
2262
2263 class CIfrShiftRight : public CIfrObj, public CIfrOpHeader {
2264 private:
2265   EFI_IFR_SHIFT_RIGHT *mShiftRight;
2266
2267 public:
2268   CIfrShiftRight (
2269   IN UINT32 LineNo
2270   ) : CIfrObj (EFI_IFR_SHIFT_RIGHT_OP, (CHAR8 **)&mShiftRight),
2271       CIfrOpHeader (EFI_IFR_SHIFT_RIGHT_OP, &mShiftRight->Header) {
2272     SetLineNo (LineNo);
2273   }
2274 };
2275
2276 class CIfrSubtract : public CIfrObj, public CIfrOpHeader {
2277 private:
2278   EFI_IFR_SUBTRACT *mSubtract;
2279
2280 public:
2281   CIfrSubtract (
2282   IN UINT32 LineNo
2283   ) : CIfrObj (EFI_IFR_SUBTRACT_OP, (CHAR8 **)&mSubtract),
2284       CIfrOpHeader (EFI_IFR_SUBTRACT_OP, &mSubtract->Header) {
2285     SetLineNo (LineNo);
2286   }
2287 };
2288
2289 class CIfrConditional : public CIfrObj, public CIfrOpHeader {
2290 private:
2291   EFI_IFR_CONDITIONAL *mConditional;
2292
2293 public:
2294   CIfrConditional (
2295   IN UINT32 LineNo
2296   ) : CIfrObj (EFI_IFR_CONDITIONAL_OP, (CHAR8 **)&mConditional),
2297       CIfrOpHeader (EFI_IFR_CONDITIONAL_OP, &mConditional->Header) {
2298     SetLineNo (LineNo);
2299   }
2300 };
2301
2302 class CIfrFind : public CIfrObj, public CIfrOpHeader {
2303 private:
2304   EFI_IFR_FIND *mFind;
2305
2306 public:
2307   CIfrFind (
2308   IN UINT32 LineNo
2309   ) : CIfrObj (EFI_IFR_FIND_OP, (CHAR8 **)&mFind),
2310       CIfrOpHeader (EFI_IFR_FIND_OP, &mFind->Header) {
2311     SetLineNo (LineNo);
2312   }
2313
2314   VOID SetFormat (IN UINT8 Format) {
2315     mFind->Format = Format;
2316   }
2317 };
2318
2319 class CIfrMid : public CIfrObj, public CIfrOpHeader {
2320 private:
2321   EFI_IFR_MID *mMid;
2322
2323 public:
2324   CIfrMid (
2325   IN UINT32 LineNo
2326   ) : CIfrObj (EFI_IFR_MID_OP, (CHAR8 **)&mMid),
2327       CIfrOpHeader (EFI_IFR_MID_OP, &mMid->Header) {
2328     SetLineNo (LineNo);
2329   }
2330 };
2331
2332 class CIfrToken : public CIfrObj, public CIfrOpHeader {
2333 private:
2334   EFI_IFR_TOKEN *mToken;
2335
2336 public:
2337   CIfrToken (
2338   IN UINT32 LineNo
2339   ) : CIfrObj (EFI_IFR_TOKEN_OP, (CHAR8 **)&mToken),
2340       CIfrOpHeader (EFI_IFR_TOKEN_OP, &mToken->Header) {
2341     SetLineNo (LineNo);
2342   }
2343 };
2344
2345 class CIfrSpan : public CIfrObj, public CIfrOpHeader {
2346 private:
2347   EFI_IFR_SPAN *mSpan;
2348
2349 public:
2350   CIfrSpan (
2351   IN UINT32 LineNo
2352   ) : CIfrObj (EFI_IFR_SPAN_OP, (CHAR8 **)&mSpan),
2353       CIfrOpHeader (EFI_IFR_SPAN_OP, &mSpan->Header) {
2354     SetLineNo (LineNo);
2355     mSpan->Flags = EFI_IFR_FLAGS_FIRST_MATCHING;
2356   }
2357
2358   EFI_VFR_RETURN_CODE SetFlags (IN UINT8 LFlags) {
2359     if (_IS_EQUAL (LFlags, EFI_IFR_FLAGS_FIRST_MATCHING)) {
2360       mSpan->Flags |= EFI_IFR_FLAGS_FIRST_MATCHING;
2361     } else if (_FLAG_TEST_AND_CLEAR (LFlags, EFI_IFR_FLAGS_FIRST_NON_MATCHING)) {
2362       mSpan->Flags |= EFI_IFR_FLAGS_FIRST_NON_MATCHING;
2363     }
2364
2365     return _FLAGS_ZERO (LFlags) ? VFR_RETURN_SUCCESS : VFR_RETURN_FLAGS_UNSUPPORTED;
2366   }
2367 };
2368
2369 #endif