BaseTools/Source/C/VfrCompile/VfrFormPkg.h

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