BaseTools/Source/C/VfrCompile/VfrFormPkg.h

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