BaseTools/Source/C/VfrCompile/VfrFormPkg.h

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