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