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