BaseTools/Source/C/VfrCompile/VfrFormPkg.h

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