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