Source/C/VfrCompile/VfrFormPkg.h

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