BaseTools/Source/C/VfrCompile/VfrFormPkg.h

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