BaseTools/Source/C/VfrCompile/VfrFormPkg.h

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