BaseTools/Source/C/VfrCompile/VfrFormPkg.h

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