BaseTools/Source/C/VfrCompile/VfrFormPkg.h

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