3 Copyright (c) 2004 - 2010, Intel Corporation. All rights reserved.<BR>
4 This program and the accompanying materials
5 are licensed and made available under the terms and conditions of the BSD License
6 which accompanies this distribution. The full text of the license may be found at
7 http://opensource.org/licenses/bsd-license.php
9 THE PROGRAM IS DISTRIBUTED UNDER THE BSD LICENSE ON AN "AS IS" BASIS,
10 WITHOUT WARRANTIES OR REPRESENTATIONS OF ANY KIND, EITHER EXPRESS OR IMPLIED.
20 #ifndef _EFIIFRCLASS_H_
21 #define _EFIIFRCLASS_H_
26 #include "VfrUtilityLib.h"
28 #define NO_QST_REFED "no question refered"
31 * The functions below are used for flags setting
33 static inline BOOLEAN
_FLAGS_ZERO (
40 static inline VOID
_FLAG_CLEAR (
48 static inline UINT8
_FLAG_TEST_AND_CLEAR (
53 UINT8 Ret
= Flags
& Mask
;
58 static inline UINT8
_IS_EQUAL (
63 return Flags
== Value
;
67 * The definition of CIfrBin
74 struct SPendingAssign
{
75 INT8
*mKey
; // key ! unique
81 struct SPendingAssign
*mNext
;
83 SPendingAssign (IN INT8
*, IN VOID
*, IN UINT32
, IN UINT32
, IN INT8
*);
86 VOID
SetAddrAndLen (IN VOID
*, IN UINT32
);
87 VOID
AssignValue (IN VOID
*, IN UINT32
);
95 struct SBufferNode
*mNext
;
101 SBufferNode
*mBufferNodeQueueHead
;
102 SBufferNode
*mBufferNodeQueueTail
;
103 SBufferNode
*mCurrBufferNode
;
105 SBufferNode
*mReadBufferNode
;
106 UINT32 mReadBufferOffset
;
110 VOID
_WRITE_PKG_LINE (IN
FILE *, IN UINT32
, IN INT8
*, IN INT8
*, IN UINT32
);
111 VOID
_WRITE_PKG_END (IN
FILE *, IN UINT32
, IN INT8
*, IN INT8
*, IN UINT32
);
114 SPendingAssign
*PendingAssignList
;
117 CFormPkg (IN UINT32 BufferSize
);
120 CHAR8
* IfrBinBufferGet (IN UINT32
);
121 inline UINT32
GetPkgLength (VOID
);
124 UINT32
Read (IN CHAR8
*, IN UINT32
);
127 EFI_VFR_RETURN_CODE
BuildPkgHdr (OUT EFI_HII_PACKAGE_HEADER
**);
128 EFI_VFR_RETURN_CODE
BuildPkg (IN
FILE *);
129 EFI_VFR_RETURN_CODE
GenCFile (IN INT8
*, IN
FILE *);
132 EFI_VFR_RETURN_CODE
AssignPending (IN INT8
*, IN VOID
*, IN UINT32
, IN UINT32
, IN INT8
*Msg
= NULL
);
133 VOID
DoPendingAssign (IN INT8
*, IN VOID
*, IN UINT32
);
134 bool HavePendingUnassigned (VOID
);
135 VOID
PendingAssignPrintAll (VOID
);
138 extern CFormPkg gCFormPkg
;
151 #define EFI_IFR_RECORDINFO_IDX_INVALUD 0xFFFFFF
152 #define EFI_IFR_RECORDINFO_IDX_START 0x0
154 class CIfrRecordInfoDB
{
158 SIfrRecord
*mIfrRecordListHead
;
159 SIfrRecord
*mIfrRecordListTail
;
161 SIfrRecord
* GetRecordInfoFromIdx (IN UINT32
);
163 CIfrRecordInfoDB (VOID
);
164 ~CIfrRecordInfoDB (VOID
);
166 inline VOID
TurnOn (VOID
) {
170 inline VOID
TurnOff (VOID
) {
174 UINT32
IfrRecordRegister (IN UINT32
, IN CHAR8
*, IN UINT8
, IN UINT32
);
175 VOID
IfrRecordInfoUpdate (IN UINT32
, IN UINT32
, IN CHAR8
*, IN UINT8
, IN UINT32
);
176 VOID
IfrRecordOutput (IN
FILE *, IN UINT32 LineNo
);
179 extern CIfrRecordInfoDB gCIfrRecordInfoDB
;
182 * The definition of CIfrObj
184 extern bool gCreateOp
;
196 VOID
_EMIT_PENDING_OBJ (VOID
);
199 CIfrObj (IN UINT8 OpCode
, OUT CHAR8
**IfrObj
= NULL
, IN UINT8 ObjBinLen
= 0, IN BOOLEAN DelayEmit
= FALSE
);
200 virtual ~CIfrObj(VOID
);
202 inline VOID
SetLineNo (IN UINT32 LineNo
) {
206 inline CHAR8
* GetObjBinAddr (VOID
) {
210 inline UINT8
GetObjBinLen (VOID
) {
214 inline bool ExpendObjBin (IN UINT8 Size
) {
215 if ((mDelayEmit
== TRUE
) && ((mObjBinLen
+ Size
) > mObjBinLen
)) {
225 * The definition of CIfrOpHeader
229 EFI_IFR_OP_HEADER
*mHeader
;
232 CIfrOpHeader (IN UINT8 OpCode
, IN VOID
*StartAddr
, IN UINT8 Length
= 0);
233 CIfrOpHeader (IN CIfrOpHeader
&);
235 VOID
IncLength (UINT8 Size
) {
236 if ((mHeader
->Length
+ Size
) > mHeader
->Length
) {
237 mHeader
->Length
+= Size
;
241 VOID
DecLength (UINT8 Size
) {
242 if (mHeader
->Length
>= Size
) {
248 return mHeader
->Length
;
252 return mHeader
->Scope
;
255 VOID
SetScope (IN UINT8 Scope
) {
256 mHeader
->Scope
= Scope
;
260 extern UINT8 gScopeCount
;
263 * The definition of CIfrStatementHeader
265 class CIfrStatementHeader
{
267 EFI_IFR_STATEMENT_HEADER
*mHeader
;
270 CIfrStatementHeader (
271 IN EFI_IFR_STATEMENT_HEADER
*StartAddr
272 ) : mHeader ((EFI_IFR_STATEMENT_HEADER
*)StartAddr
) {
274 mHeader
->Help
= EFI_STRING_ID_INVALID
;
275 mHeader
->Prompt
= EFI_STRING_ID_INVALID
;
278 EFI_IFR_STATEMENT_HEADER
*GetStatementHeader () {
282 VOID
SetPrompt (IN EFI_STRING_ID Prompt
) {
283 mHeader
->Prompt
= Prompt
;
286 VOID
SetHelp (IN EFI_STRING_ID Help
) {
287 mHeader
->Help
= Help
;
292 * The definition of CIfrQuestionHeader
294 #define EFI_IFR_QUESTION_FLAG_DEFAULT 0
296 class CIfrQuestionHeader
: public CIfrStatementHeader
{
298 EFI_IFR_QUESTION_HEADER
*mHeader
;
300 EFI_IFR_STATEMENT_HEADER
* QH2SH (EFI_IFR_QUESTION_HEADER
*Qheader
) {
301 return &(Qheader
)->Header
;
305 EFI_QUESTION_ID
QUESTION_ID (VOID
) {
306 return mHeader
->QuestionId
;
309 EFI_VARSTORE_ID
VARSTORE_ID (VOID
) {
310 return mHeader
->VarStoreId
;
313 VOID
VARSTORE_INFO (OUT EFI_VARSTORE_INFO
*Info
) {
315 Info
->mVarStoreId
= mHeader
->VarStoreId
;
316 memcpy (&Info
->mVarStoreId
, &mHeader
->VarStoreInfo
, sizeof (Info
->mVarStoreId
));
321 return mHeader
->Flags
;
326 IN EFI_IFR_QUESTION_HEADER
*StartAddr
,
327 IN UINT8 Flags
= EFI_IFR_QUESTION_FLAG_DEFAULT
328 ) : CIfrStatementHeader (QH2SH(StartAddr
)) {
330 mHeader
->QuestionId
= EFI_QUESTION_ID_INVALID
;
331 mHeader
->VarStoreId
= EFI_VARSTORE_ID_INVALID
;
332 mHeader
->VarStoreInfo
.VarName
= EFI_STRING_ID_INVALID
;
333 mHeader
->VarStoreInfo
.VarOffset
= EFI_VAROFFSET_INVALID
;
334 mHeader
->Flags
= Flags
;
337 VOID
SetQuestionId (IN EFI_QUESTION_ID QuestionId
) {
338 mHeader
->QuestionId
= QuestionId
;
341 VOID
SetVarStoreInfo (IN EFI_VARSTORE_INFO
*Info
) {
342 mHeader
->VarStoreId
= Info
->mVarStoreId
;
343 mHeader
->VarStoreInfo
.VarName
= Info
->mInfo
.mVarName
;
344 mHeader
->VarStoreInfo
.VarOffset
= Info
->mInfo
.mVarOffset
;
347 EFI_VFR_RETURN_CODE
SetFlags (IN UINT8 Flags
) {
348 if (_FLAG_TEST_AND_CLEAR (Flags
, EFI_IFR_FLAG_READ_ONLY
)) {
349 mHeader
->Flags
|= EFI_IFR_FLAG_READ_ONLY
;
352 _FLAG_CLEAR (Flags
, 0x02);
354 if (_FLAG_TEST_AND_CLEAR (Flags
, EFI_IFR_FLAG_CALLBACK
)) {
355 mHeader
->Flags
|= EFI_IFR_FLAG_CALLBACK
;
358 _FLAG_CLEAR (Flags
, 0x08);
360 if (_FLAG_TEST_AND_CLEAR (Flags
, EFI_IFR_FLAG_RESET_REQUIRED
)) {
361 mHeader
->Flags
|= EFI_IFR_FLAG_RESET_REQUIRED
;
364 _FLAG_CLEAR (Flags
, 0x20);
366 if (_FLAG_TEST_AND_CLEAR (Flags
, EFI_IFR_FLAG_OPTIONS_ONLY
)) {
367 mHeader
->Flags
|= EFI_IFR_FLAG_OPTIONS_ONLY
;
370 return _FLAGS_ZERO (Flags
) ? VFR_RETURN_SUCCESS
: VFR_RETURN_FLAGS_UNSUPPORTED
;
375 * The definition of CIfrMinMaxStepData
377 class CIfrMinMaxStepData
{
379 MINMAXSTEP_DATA
*mMinMaxStepData
;
384 CIfrMinMaxStepData (MINMAXSTEP_DATA
*DataAddr
, BOOLEAN NumericOpcode
=FALSE
) : mMinMaxStepData (DataAddr
) {
385 mMinMaxStepData
->u64
.MinValue
= 0;
386 mMinMaxStepData
->u64
.MaxValue
= 0;
387 mMinMaxStepData
->u64
.Step
= 0;
389 IsNumeric
= NumericOpcode
;
392 VOID
SetMinMaxStepData (IN UINT64 MinValue
, IN UINT64 MaxValue
, IN UINT64 Step
) {
394 mMinMaxStepData
->u64
.MinValue
= MinValue
;
395 mMinMaxStepData
->u64
.MaxValue
= MaxValue
;
398 if (MinValue
< mMinMaxStepData
->u64
.MinValue
) {
399 mMinMaxStepData
->u64
.MinValue
= MinValue
;
401 if (MaxValue
> mMinMaxStepData
->u64
.MaxValue
) {
402 mMinMaxStepData
->u64
.MaxValue
= MaxValue
;
405 mMinMaxStepData
->u64
.Step
= Step
;
408 VOID
SetMinMaxStepData (IN UINT32 MinValue
, IN UINT32 MaxValue
, IN UINT32 Step
) {
410 mMinMaxStepData
->u32
.MinValue
= MinValue
;
411 mMinMaxStepData
->u32
.MaxValue
= MaxValue
;
414 if (MinValue
< mMinMaxStepData
->u32
.MinValue
) {
415 mMinMaxStepData
->u32
.MinValue
= MinValue
;
417 if (MaxValue
> mMinMaxStepData
->u32
.MaxValue
) {
418 mMinMaxStepData
->u32
.MaxValue
= MaxValue
;
421 mMinMaxStepData
->u32
.Step
= Step
;
424 VOID
SetMinMaxStepData (IN UINT16 MinValue
, IN UINT16 MaxValue
, IN UINT16 Step
) {
426 mMinMaxStepData
->u16
.MinValue
= MinValue
;
427 mMinMaxStepData
->u16
.MaxValue
= MaxValue
;
430 if (MinValue
< mMinMaxStepData
->u16
.MinValue
) {
431 mMinMaxStepData
->u16
.MinValue
= MinValue
;
433 if (MaxValue
> mMinMaxStepData
->u16
.MaxValue
) {
434 mMinMaxStepData
->u16
.MaxValue
= MaxValue
;
437 mMinMaxStepData
->u16
.Step
= Step
;
440 VOID
SetMinMaxStepData (IN UINT8 MinValue
, IN UINT8 MaxValue
, IN UINT8 Step
) {
442 mMinMaxStepData
->u8
.MinValue
= MinValue
;
443 mMinMaxStepData
->u8
.MaxValue
= MaxValue
;
446 if (MinValue
< mMinMaxStepData
->u8
.MinValue
) {
447 mMinMaxStepData
->u8
.MinValue
= MinValue
;
449 if (MaxValue
> mMinMaxStepData
->u8
.MaxValue
) {
450 mMinMaxStepData
->u8
.MaxValue
= MaxValue
;
453 mMinMaxStepData
->u8
.Step
= Step
;
456 UINT64
GetMinData (UINT8 VarType
) {
459 case EFI_IFR_TYPE_NUM_SIZE_64
:
460 MinValue
= mMinMaxStepData
->u64
.MinValue
;
462 case EFI_IFR_TYPE_NUM_SIZE_32
:
463 MinValue
= (UINT64
) mMinMaxStepData
->u32
.MinValue
;
465 case EFI_IFR_TYPE_NUM_SIZE_16
:
466 MinValue
= (UINT64
) mMinMaxStepData
->u16
.MinValue
;
468 case EFI_IFR_TYPE_NUM_SIZE_8
:
469 MinValue
= (UINT64
) mMinMaxStepData
->u8
.MinValue
;
477 UINT64
GetMaxData (UINT8 VarType
) {
480 case EFI_IFR_TYPE_NUM_SIZE_64
:
481 MaxValue
= mMinMaxStepData
->u64
.MaxValue
;
483 case EFI_IFR_TYPE_NUM_SIZE_32
:
484 MaxValue
= (UINT64
) mMinMaxStepData
->u32
.MaxValue
;
486 case EFI_IFR_TYPE_NUM_SIZE_16
:
487 MaxValue
= (UINT64
) mMinMaxStepData
->u16
.MaxValue
;
489 case EFI_IFR_TYPE_NUM_SIZE_8
:
490 MaxValue
= (UINT64
) mMinMaxStepData
->u8
.MaxValue
;
498 UINT64
GetStepData (UINT8 VarType
) {
501 case EFI_IFR_TYPE_NUM_SIZE_64
:
502 MaxValue
= mMinMaxStepData
->u64
.Step
;
504 case EFI_IFR_TYPE_NUM_SIZE_32
:
505 MaxValue
= (UINT64
) mMinMaxStepData
->u32
.Step
;
507 case EFI_IFR_TYPE_NUM_SIZE_16
:
508 MaxValue
= (UINT64
) mMinMaxStepData
->u16
.Step
;
510 case EFI_IFR_TYPE_NUM_SIZE_8
:
511 MaxValue
= (UINT64
) mMinMaxStepData
->u8
.Step
;
519 BOOLEAN
IsNumericOpcode () {
524 static CIfrQuestionHeader
*gCurrentQuestion
= NULL
;
525 static CIfrMinMaxStepData
*gCurrentMinMaxData
= NULL
;
528 * The definition of all of the UEFI IFR Objects
530 class CIfrFormSet
: public CIfrObj
, public CIfrOpHeader
{
532 EFI_IFR_FORM_SET
*mFormSet
;
535 CIfrFormSet (UINT8 Size
) : CIfrObj (EFI_IFR_FORM_SET_OP
, (CHAR8
**)&mFormSet
, Size
),
536 CIfrOpHeader (EFI_IFR_FORM_SET_OP
, &mFormSet
->Header
, Size
) {
537 mFormSet
->Help
= EFI_STRING_ID_INVALID
;
538 mFormSet
->FormSetTitle
= EFI_STRING_ID_INVALID
;
540 memset (&mFormSet
->Guid
, 0, sizeof (EFI_GUID
));
543 VOID
SetGuid (IN EFI_GUID
*Guid
) {
544 memcpy (&mFormSet
->Guid
, Guid
, sizeof (EFI_GUID
));
547 VOID
SetFormSetTitle (IN EFI_STRING_ID FormSetTitle
) {
548 mFormSet
->FormSetTitle
= FormSetTitle
;
551 VOID
SetHelp (IN EFI_STRING_ID Help
) {
552 mFormSet
->Help
= Help
;
555 VOID
SetClassGuid (IN EFI_GUID
*Guid
) {
556 if (mFormSet
->Flags
> 0 && ExpendObjBin(sizeof(EFI_GUID
))) {
557 IncLength (sizeof (EFI_GUID
));
559 memcpy (&(mFormSet
->ClassGuid
[mFormSet
->Flags
++]), Guid
, sizeof (EFI_GUID
));
563 return mFormSet
->Flags
;
567 class CIfrEnd
: public CIfrObj
, public CIfrOpHeader
{
572 CIfrEnd () : CIfrObj (EFI_IFR_END_OP
, (CHAR8
**)&mEnd
),
573 CIfrOpHeader (EFI_IFR_END_OP
, &mEnd
->Header
) {}
576 class CIfrDefaultStore
: public CIfrObj
, public CIfrOpHeader
{
578 EFI_IFR_DEFAULTSTORE
*mDefaultStore
;
581 CIfrDefaultStore () : CIfrObj (EFI_IFR_DEFAULTSTORE_OP
, (CHAR8
**)&mDefaultStore
),
582 CIfrOpHeader (EFI_IFR_DEFAULTSTORE_OP
, &mDefaultStore
->Header
) {
583 mDefaultStore
->DefaultId
= EFI_VARSTORE_ID_INVALID
;
584 mDefaultStore
->DefaultName
= EFI_STRING_ID_INVALID
;
587 VOID
SetDefaultName (IN EFI_STRING_ID DefaultName
) {
588 mDefaultStore
->DefaultName
= DefaultName
;
591 VOID
SetDefaultId (IN UINT16 DefaultId
) {
592 mDefaultStore
->DefaultId
= DefaultId
;
596 #define EFI_FORM_ID_MAX 0xFFFF
597 #define EFI_FREE_FORM_ID_BITMAP_SIZE ((EFI_FORM_ID_MAX + 1) / EFI_BITS_PER_UINT32)
599 class CIfrForm
: public CIfrObj
, public CIfrOpHeader
{
603 STATIC UINT32 FormIdBitMap
[EFI_FREE_FORM_ID_BITMAP_SIZE
];
605 STATIC BOOLEAN
ChekFormIdFree (IN EFI_FORM_ID FormId
) {
606 UINT32 Index
= (FormId
/ EFI_BITS_PER_UINT32
);
607 UINT32 Offset
= (FormId
% EFI_BITS_PER_UINT32
);
609 return (FormIdBitMap
[Index
] & (0x80000000 >> Offset
)) == 0;
612 STATIC VOID
MarkFormIdUsed (IN EFI_FORM_ID FormId
) {
613 UINT32 Index
= (FormId
/ EFI_BITS_PER_UINT32
);
614 UINT32 Offset
= (FormId
% EFI_BITS_PER_UINT32
);
616 FormIdBitMap
[Index
] |= (0x80000000 >> Offset
);
620 CIfrForm () : CIfrObj (EFI_IFR_FORM_OP
, (CHAR8
**)&mForm
),
621 CIfrOpHeader (EFI_IFR_FORM_OP
, &mForm
->Header
) {
623 mForm
->FormTitle
= EFI_STRING_ID_INVALID
;
626 EFI_VFR_RETURN_CODE
SetFormId (IN EFI_FORM_ID FormId
) {
627 if (CIfrForm::ChekFormIdFree (FormId
) == FALSE
) {
628 return VFR_RETURN_FORMID_REDEFINED
;
630 mForm
->FormId
= FormId
;
631 CIfrForm::MarkFormIdUsed (FormId
);
632 return VFR_RETURN_SUCCESS
;
635 VOID
SetFormTitle (IN EFI_STRING_ID FormTitle
) {
636 mForm
->FormTitle
= FormTitle
;
640 class CIfrVarStore
: public CIfrObj
, public CIfrOpHeader
{
642 EFI_IFR_VARSTORE
*mVarStore
;
645 CIfrVarStore () : CIfrObj (EFI_IFR_VARSTORE_OP
, (CHAR8
**)&mVarStore
, sizeof (EFI_IFR_VARSTORE
), TRUE
),
646 CIfrOpHeader (EFI_IFR_VARSTORE_OP
, &mVarStore
->Header
) {
647 mVarStore
->VarStoreId
= EFI_VARSTORE_ID_INVALID
;
649 memset (&mVarStore
->Guid
, 0, sizeof (EFI_GUID
));
650 mVarStore
->Name
[0] = '\0';
653 VOID
SetGuid (IN EFI_GUID
*Guid
) {
654 memcpy (&mVarStore
->Guid
, Guid
, sizeof (EFI_GUID
));
657 VOID
SetVarStoreId (IN EFI_VARSTORE_ID VarStoreId
) {
658 mVarStore
->VarStoreId
= VarStoreId
;
661 VOID
SetSize (IN UINT16 Size
) {
662 mVarStore
->Size
= Size
;
665 VOID
SetName (IN INT8
*Name
) {
671 if (ExpendObjBin (Len
) == TRUE
) {
673 strcpy ((INT8
*)(mVarStore
->Name
), Name
);
680 class CIfrVarStoreEfi
: public CIfrObj
, public CIfrOpHeader
{
682 EFI_IFR_VARSTORE_EFI
*mVarStoreEfi
;
685 CIfrVarStoreEfi () : CIfrObj (EFI_IFR_VARSTORE_EFI_OP
, (CHAR8
**)&mVarStoreEfi
),
686 CIfrOpHeader (EFI_IFR_VARSTORE_EFI_OP
, &mVarStoreEfi
->Header
) {
687 mVarStoreEfi
->VarStoreId
= EFI_VAROFFSET_INVALID
;
688 memset (&mVarStoreEfi
->Guid
, 0, sizeof (EFI_GUID
));
691 VOID
SetGuid (IN EFI_GUID
*Guid
) {
692 memcpy (&mVarStoreEfi
->Guid
, Guid
, sizeof (EFI_GUID
));
695 VOID
SetVarStoreId (IN UINT16 VarStoreId
) {
696 mVarStoreEfi
->VarStoreId
= VarStoreId
;
699 VOID
SetAttributes (IN UINT32 Attributes
) {
700 mVarStoreEfi
->Attributes
= Attributes
;
704 class CIfrVarStoreNameValue
: public CIfrObj
, public CIfrOpHeader
{
706 EFI_IFR_VARSTORE_NAME_VALUE
*mVarStoreNameValue
;
709 CIfrVarStoreNameValue () : CIfrObj (EFI_IFR_VARSTORE_NAME_VALUE_OP
, (CHAR8
**)&mVarStoreNameValue
),
710 CIfrOpHeader (EFI_IFR_VARSTORE_NAME_VALUE_OP
, &mVarStoreNameValue
->Header
) {
711 mVarStoreNameValue
->VarStoreId
= EFI_VAROFFSET_INVALID
;
712 memset (&mVarStoreNameValue
->Guid
, 0, sizeof (EFI_GUID
));
715 VOID
SetGuid (IN EFI_GUID
*Guid
) {
716 memcpy (&mVarStoreNameValue
->Guid
, Guid
, sizeof (EFI_GUID
));
719 VOID
SetVarStoreId (IN UINT16 VarStoreId
) {
720 mVarStoreNameValue
->VarStoreId
= VarStoreId
;
724 class CIfrImage
: public CIfrObj
, public CIfrOpHeader
{
726 EFI_IFR_IMAGE
*mImage
;
729 CIfrImage () : CIfrObj (EFI_IFR_IMAGE_OP
, (CHAR8
**)&mImage
),
730 CIfrOpHeader (EFI_IFR_FORM_OP
, &mImage
->Header
) {
731 mImage
->Id
= EFI_IMAGE_ID_INVALID
;
734 VOID
SetImageId (IN EFI_IMAGE_ID ImageId
) {
735 mImage
->Id
= ImageId
;
739 class CIfrLocked
: public CIfrObj
, public CIfrOpHeader
{
741 EFI_IFR_LOCKED
*mLocked
;
744 CIfrLocked () : CIfrObj (EFI_IFR_LOCKED_OP
, (CHAR8
**)&mLocked
),
745 CIfrOpHeader (EFI_IFR_LOCKED_OP
, &mLocked
->Header
) {}
748 class CIfrRule
: public CIfrObj
, public CIfrOpHeader
{
753 CIfrRule () : CIfrObj (EFI_IFR_RULE_OP
, (CHAR8
**)&mRule
),
754 mRule ((EFI_IFR_RULE
*)GetObjBinAddr()),
755 CIfrOpHeader (EFI_IFR_RULE_OP
, &mRule
->Header
) {
756 mRule
->RuleId
= EFI_RULE_ID_INVALID
;
759 VOID
SetRuleId (IN UINT8 RuleId
) {
760 mRule
->RuleId
= RuleId
;
764 static EFI_IFR_TYPE_VALUE gZeroEfiIfrTypeValue
= {0, };
766 class CIfrDefault
: public CIfrObj
, public CIfrOpHeader
{
768 EFI_IFR_DEFAULT
*mDefault
;
772 IN UINT16 DefaultId
= EFI_HII_DEFAULT_CLASS_STANDARD
,
773 IN UINT8 Type
= EFI_IFR_TYPE_OTHER
,
774 IN EFI_IFR_TYPE_VALUE Value
= gZeroEfiIfrTypeValue
775 ) : CIfrObj (EFI_IFR_DEFAULT_OP
, (CHAR8
**)&mDefault
),
776 CIfrOpHeader (EFI_IFR_DEFAULT_OP
, &mDefault
->Header
) {
777 mDefault
->Type
= Type
;
778 mDefault
->Value
= Value
;
779 mDefault
->DefaultId
= DefaultId
;
782 VOID
SetDefaultId (IN UINT16 DefaultId
) {
783 mDefault
->DefaultId
= DefaultId
;
786 VOID
SetType (IN UINT8 Type
) {
787 mDefault
->Type
= Type
;
790 VOID
SetValue (IN EFI_IFR_TYPE_VALUE Value
) {
791 mDefault
->Value
= Value
;
795 class CIfrValue
: public CIfrObj
, public CIfrOpHeader
{
797 EFI_IFR_VALUE
*mValue
;
800 CIfrValue () : CIfrObj (EFI_IFR_VALUE_OP
, (CHAR8
**)&mValue
),
801 CIfrOpHeader (EFI_IFR_VALUE_OP
, &mValue
->Header
) {}
805 class CIfrSubtitle
: public CIfrObj
, public CIfrOpHeader
, public CIfrStatementHeader
{
807 EFI_IFR_SUBTITLE
*mSubtitle
;
810 CIfrSubtitle () : CIfrObj (EFI_IFR_SUBTITLE_OP
, (CHAR8
**)&mSubtitle
),
811 CIfrOpHeader (EFI_IFR_SUBTITLE_OP
, &mSubtitle
->Header
),
812 CIfrStatementHeader (&mSubtitle
->Statement
) {
813 mSubtitle
->Flags
= 0;
816 EFI_VFR_RETURN_CODE
SetFlags (IN UINT8 LFlags
) {
817 if (_FLAG_TEST_AND_CLEAR (LFlags
, EFI_IFR_FLAGS_HORIZONTAL
)) {
818 mSubtitle
->Flags
|= EFI_IFR_FLAGS_HORIZONTAL
;
821 return _FLAGS_ZERO (LFlags
) ? VFR_RETURN_SUCCESS
: VFR_RETURN_FLAGS_UNSUPPORTED
;
825 class CIfrText
: public CIfrObj
, public CIfrOpHeader
, public CIfrStatementHeader
{
830 CIfrText () : CIfrObj (EFI_IFR_TEXT_OP
, (CHAR8
**)&mText
),
831 CIfrOpHeader (EFI_IFR_TEXT_OP
, &mText
->Header
),
832 CIfrStatementHeader (&mText
->Statement
) {
833 mText
->TextTwo
= EFI_STRING_ID_INVALID
;
836 VOID
SetTextTwo (IN EFI_STRING_ID StringId
) {
837 mText
->TextTwo
= StringId
;
841 class CIfrRef
: public CIfrObj
, public CIfrOpHeader
, public CIfrQuestionHeader
{
846 CIfrRef () : CIfrObj (EFI_IFR_REF_OP
, (CHAR8
**)&mRef
),
847 CIfrOpHeader (EFI_IFR_REF_OP
, &mRef
->Header
),
848 CIfrQuestionHeader (&mRef
->Question
) {
852 VOID
SetFormId (IN EFI_FORM_ID FormId
) {
853 mRef
->FormId
= FormId
;
857 class CIfrRef2
: public CIfrObj
, public CIfrOpHeader
, public CIfrQuestionHeader
{
862 CIfrRef2 () : CIfrObj (EFI_IFR_REF_OP
, (CHAR8
**)&mRef2
, sizeof (EFI_IFR_REF2
)),
863 CIfrOpHeader (EFI_IFR_REF_OP
, &mRef2
->Header
, sizeof (EFI_IFR_REF2
)),
864 CIfrQuestionHeader (&mRef2
->Question
) {
866 mRef2
->QuestionId
= EFI_QUESTION_ID_INVALID
;
869 VOID
SetFormId (IN EFI_FORM_ID FormId
) {
870 mRef2
->FormId
= FormId
;
873 EFI_VFR_RETURN_CODE
SetQuestionId (IN EFI_QUESTION_ID QuestionId
) {
874 if (QuestionId
== EFI_QUESTION_ID_INVALID
) {
875 return VFR_RETURN_UNDEFINED
;
877 mRef2
->QuestionId
= QuestionId
;
878 return VFR_RETURN_SUCCESS
;
882 class CIfrRef3
: public CIfrObj
, public CIfrOpHeader
, public CIfrQuestionHeader
{
887 CIfrRef3 () : CIfrObj (EFI_IFR_REF_OP
, (CHAR8
**)&mRef3
, sizeof(EFI_IFR_REF3
)),
888 CIfrOpHeader (EFI_IFR_REF_OP
, &mRef3
->Header
, sizeof (EFI_IFR_REF3
)),
889 CIfrQuestionHeader (&mRef3
->Question
) {
891 mRef3
->QuestionId
= EFI_QUESTION_ID_INVALID
;
892 memset (&mRef3
->FormSetId
, 0, sizeof (EFI_GUID
));
895 VOID
SetFormId (IN EFI_FORM_ID FormId
) {
896 mRef3
->FormId
= FormId
;
899 VOID
SetQuestionId (IN EFI_QUESTION_ID QuestionId
) {
900 mRef3
->QuestionId
= QuestionId
;
903 VOID
SetFormSetId (IN EFI_GUID FormSetId
) {
904 mRef3
->FormSetId
= FormSetId
;
908 class CIfrRef4
: public CIfrObj
, public CIfrOpHeader
, public CIfrQuestionHeader
{
913 CIfrRef4 () : CIfrObj (EFI_IFR_REF_OP
, (CHAR8
**)&mRef4
, sizeof(EFI_IFR_REF3
)),
914 CIfrOpHeader (EFI_IFR_REF_OP
, &mRef4
->Header
, sizeof (EFI_IFR_REF3
)),
915 CIfrQuestionHeader (&mRef4
->Question
) {
917 mRef4
->QuestionId
= EFI_QUESTION_ID_INVALID
;
918 memset (&mRef4
->FormSetId
, 0, sizeof (EFI_GUID
));
919 mRef4
->DevicePath
= EFI_STRING_ID_INVALID
;
922 VOID
SetFormId (IN EFI_FORM_ID FormId
) {
923 mRef4
->FormId
= FormId
;
926 VOID
SetQuestionId (IN EFI_QUESTION_ID QuestionId
) {
927 mRef4
->QuestionId
= QuestionId
;
930 VOID
SetFormSetId (IN EFI_GUID FormSetId
) {
931 mRef4
->FormSetId
= FormSetId
;
934 VOID
SetDevicePath (IN EFI_STRING_ID DevicePath
) {
935 mRef4
->DevicePath
= DevicePath
;
939 class CIfrResetButton
: public CIfrObj
, public CIfrOpHeader
, public CIfrStatementHeader
{
941 EFI_IFR_RESET_BUTTON
*mResetButton
;
944 CIfrResetButton () : CIfrObj (EFI_IFR_RESET_BUTTON_OP
, (CHAR8
**)&mResetButton
),
945 CIfrOpHeader (EFI_IFR_RESET_BUTTON_OP
, &mResetButton
->Header
),
946 CIfrStatementHeader (&mResetButton
->Statement
) {
947 mResetButton
->DefaultId
= EFI_HII_DEFAULT_CLASS_STANDARD
;
950 VOID
SetDefaultId (IN UINT16 DefaultId
) {
951 mResetButton
->DefaultId
= DefaultId
;
955 class CIfrCheckBox
: public CIfrObj
, public CIfrOpHeader
, public CIfrQuestionHeader
{
957 EFI_IFR_CHECKBOX
*mCheckBox
;
960 CIfrCheckBox () : CIfrObj (EFI_IFR_CHECKBOX_OP
, (CHAR8
**)&mCheckBox
),
961 CIfrOpHeader (EFI_IFR_CHECKBOX_OP
, &mCheckBox
->Header
),
962 CIfrQuestionHeader (&mCheckBox
->Question
) {
963 mCheckBox
->Flags
= 0;
964 gCurrentQuestion
= this;
968 gCurrentQuestion
= NULL
;
971 EFI_VFR_RETURN_CODE
SetFlags (IN UINT8 HFlags
, UINT8 LFlags
) {
972 EFI_VFR_RETURN_CODE Ret
;
974 Ret
= CIfrQuestionHeader::SetFlags (HFlags
);
975 if (Ret
!= VFR_RETURN_SUCCESS
) {
979 if (_FLAG_TEST_AND_CLEAR (LFlags
, EFI_IFR_CHECKBOX_DEFAULT
)) {
980 mCheckBox
->Flags
|= EFI_IFR_CHECKBOX_DEFAULT
;
983 if (_FLAG_TEST_AND_CLEAR (LFlags
, EFI_IFR_CHECKBOX_DEFAULT_MFG
)) {
984 mCheckBox
->Flags
|= EFI_IFR_CHECKBOX_DEFAULT_MFG
;
987 return _FLAGS_ZERO (LFlags
) ? VFR_RETURN_SUCCESS
: VFR_RETURN_FLAGS_UNSUPPORTED
;
990 UINT8
GetFlags (VOID
) {
991 return mCheckBox
->Flags
;
995 class CIfrAction
: public CIfrObj
, public CIfrOpHeader
, public CIfrQuestionHeader
{
997 EFI_IFR_ACTION
*mAction
;
1000 CIfrAction () : CIfrObj (EFI_IFR_ACTION_OP
, (CHAR8
**)&mAction
),
1001 CIfrOpHeader (EFI_IFR_ACTION_OP
, &mAction
->Header
),
1002 CIfrQuestionHeader (&mAction
->Question
) {
1003 mAction
->QuestionConfig
= EFI_STRING_ID_INVALID
;
1006 VOID
SetQuestionConfig (IN EFI_STRING_ID QuestionConfig
) {
1007 mAction
->QuestionConfig
= QuestionConfig
;
1011 class CIfrDate
: public CIfrObj
, public CIfrOpHeader
, public CIfrQuestionHeader
{
1013 EFI_IFR_DATE
*mDate
;
1016 CIfrDate () : CIfrObj (EFI_IFR_DATE_OP
, (CHAR8
**)&mDate
),
1017 CIfrOpHeader (EFI_IFR_DATE_OP
, &mDate
->Header
),
1018 CIfrQuestionHeader (&mDate
->Question
) {
1022 EFI_VFR_RETURN_CODE
SetFlags (IN UINT8 HFlags
, IN UINT8 LFlags
) {
1023 EFI_VFR_RETURN_CODE Ret
;
1025 Ret
= CIfrQuestionHeader::SetFlags (HFlags
);
1026 if (Ret
!= VFR_RETURN_SUCCESS
) {
1030 if (_FLAG_TEST_AND_CLEAR (LFlags
, EFI_QF_DATE_YEAR_SUPPRESS
)) {
1031 mDate
->Flags
|= EFI_QF_DATE_YEAR_SUPPRESS
;
1034 if (_FLAG_TEST_AND_CLEAR (LFlags
, EFI_QF_DATE_MONTH_SUPPRESS
)) {
1035 mDate
->Flags
|= EFI_QF_DATE_MONTH_SUPPRESS
;
1038 if (_FLAG_TEST_AND_CLEAR (LFlags
, EFI_QF_DATE_DAY_SUPPRESS
)) {
1039 mDate
->Flags
|= EFI_QF_DATE_DAY_SUPPRESS
;
1042 if (_FLAG_TEST_AND_CLEAR (LFlags
, QF_DATE_STORAGE_NORMAL
)) {
1043 mDate
->Flags
|= QF_DATE_STORAGE_NORMAL
;
1044 } else if (_FLAG_TEST_AND_CLEAR (LFlags
, QF_DATE_STORAGE_TIME
)) {
1045 mDate
->Flags
|= QF_DATE_STORAGE_TIME
;
1046 } else if (_FLAG_TEST_AND_CLEAR (LFlags
, QF_DATE_STORAGE_WAKEUP
)) {
1047 mDate
->Flags
|= QF_DATE_STORAGE_WAKEUP
;
1050 return _FLAGS_ZERO (LFlags
) ? VFR_RETURN_SUCCESS
: VFR_RETURN_FLAGS_UNSUPPORTED
;
1054 class CIfrNumeric
: public CIfrObj
, public CIfrOpHeader
, public CIfrQuestionHeader
, public CIfrMinMaxStepData
{
1056 EFI_IFR_NUMERIC
*mNumeric
;
1059 CIfrNumeric () : CIfrObj (EFI_IFR_NUMERIC_OP
, (CHAR8
**)&mNumeric
),
1060 CIfrOpHeader (EFI_IFR_NUMERIC_OP
, &mNumeric
->Header
),
1061 CIfrQuestionHeader (&mNumeric
->Question
),
1062 CIfrMinMaxStepData (&mNumeric
->data
, TRUE
) {
1063 mNumeric
->Flags
= EFI_IFR_NUMERIC_SIZE_1
| EFI_IFR_DISPLAY_UINT_DEC
;
1064 gCurrentQuestion
= this;
1065 gCurrentMinMaxData
= this;
1069 gCurrentQuestion
= NULL
;
1070 gCurrentMinMaxData
= NULL
;
1073 EFI_VFR_RETURN_CODE
SetFlags (IN UINT8 HFlags
, IN UINT8 LFlags
) {
1074 EFI_VFR_RETURN_CODE Ret
;
1076 Ret
= CIfrQuestionHeader::SetFlags (HFlags
);
1077 if (Ret
!= VFR_RETURN_SUCCESS
) {
1081 if (LFlags
& EFI_IFR_DISPLAY
) {
1082 mNumeric
->Flags
= LFlags
;
1084 mNumeric
->Flags
= LFlags
| EFI_IFR_DISPLAY_UINT_DEC
;
1086 return VFR_RETURN_SUCCESS
;
1090 class CIfrOneOf
: public CIfrObj
, public CIfrOpHeader
, public CIfrQuestionHeader
, public CIfrMinMaxStepData
{
1092 EFI_IFR_ONE_OF
*mOneOf
;
1095 CIfrOneOf () : CIfrObj (EFI_IFR_ONE_OF_OP
, (CHAR8
**)&mOneOf
),
1096 CIfrOpHeader (EFI_IFR_ONE_OF_OP
, &mOneOf
->Header
),
1097 CIfrQuestionHeader (&mOneOf
->Question
),
1098 CIfrMinMaxStepData (&mOneOf
->data
) {
1100 gCurrentQuestion
= this;
1101 gCurrentMinMaxData
= this;
1105 gCurrentQuestion
= NULL
;
1106 gCurrentMinMaxData
= NULL
;
1109 EFI_VFR_RETURN_CODE
SetFlags (IN UINT8 HFlags
, IN UINT8 LFlags
) {
1110 EFI_VFR_RETURN_CODE Ret
;
1112 Ret
= CIfrQuestionHeader::SetFlags (HFlags
);
1113 if (Ret
!= VFR_RETURN_SUCCESS
) {
1117 if (LFlags
& EFI_IFR_DISPLAY
) {
1118 mOneOf
->Flags
= LFlags
;
1120 mOneOf
->Flags
= LFlags
| EFI_IFR_DISPLAY_UINT_DEC
;
1122 return VFR_RETURN_SUCCESS
;
1126 class CIfrString
: public CIfrObj
, public CIfrOpHeader
, public CIfrQuestionHeader
{
1128 EFI_IFR_STRING
*mString
;
1131 CIfrString () : CIfrObj (EFI_IFR_STRING_OP
, (CHAR8
**)&mString
),
1132 CIfrOpHeader (EFI_IFR_STRING_OP
, &mString
->Header
),
1133 CIfrQuestionHeader (&mString
->Question
) {
1135 mString
->MinSize
= 0;
1136 mString
->MaxSize
= 0;
1137 gCurrentQuestion
= this;
1141 gCurrentQuestion
= NULL
;
1144 EFI_VFR_RETURN_CODE
SetFlags (IN UINT8 HFlags
, IN UINT8 LFlags
) {
1145 EFI_VFR_RETURN_CODE Ret
;
1147 Ret
= CIfrQuestionHeader::SetFlags (HFlags
);
1148 if (Ret
!= VFR_RETURN_SUCCESS
) {
1152 if (_FLAG_TEST_AND_CLEAR (LFlags
, EFI_IFR_STRING_MULTI_LINE
)) {
1153 mString
->Flags
|= EFI_IFR_STRING_MULTI_LINE
;
1156 return _FLAGS_ZERO (LFlags
) ? VFR_RETURN_SUCCESS
: VFR_RETURN_FLAGS_UNSUPPORTED
;
1159 VOID
SetMinSize (IN UINT8 Flags
) {
1160 mString
->MinSize
= Flags
;
1163 VOID
SetMaxSize (IN UINT8 MaxSize
) {
1164 mString
->MaxSize
= MaxSize
;
1168 class CIfrPassword
: public CIfrObj
, public CIfrOpHeader
, public CIfrQuestionHeader
{
1170 EFI_IFR_PASSWORD
*mPassword
;
1173 CIfrPassword () : CIfrObj (EFI_IFR_PASSWORD_OP
, (CHAR8
**)&mPassword
),
1174 CIfrOpHeader (EFI_IFR_PASSWORD_OP
, &mPassword
->Header
),
1175 CIfrQuestionHeader (&mPassword
->Question
) {
1176 mPassword
->MinSize
= 0;
1177 mPassword
->MaxSize
= 0;
1178 gCurrentQuestion
= this;
1182 gCurrentQuestion
= NULL
;
1185 VOID
SetMinSize (IN UINT16 MinSize
) {
1186 mPassword
->MinSize
= MinSize
;
1189 VOID
SetMaxSize (IN UINT16 MaxSize
) {
1190 mPassword
->MaxSize
= MaxSize
;
1194 class CIfrOrderedList
: public CIfrObj
, public CIfrOpHeader
, public CIfrQuestionHeader
{
1196 EFI_IFR_ORDERED_LIST
*mOrderedList
;
1199 CIfrOrderedList () : CIfrObj (EFI_IFR_ORDERED_LIST_OP
, (CHAR8
**)&mOrderedList
),
1200 CIfrOpHeader (EFI_IFR_ORDERED_LIST_OP
, &mOrderedList
->Header
),
1201 CIfrQuestionHeader (&mOrderedList
->Question
) {
1202 mOrderedList
->MaxContainers
= 0;
1203 mOrderedList
->Flags
= 0;
1204 gCurrentQuestion
= this;
1207 ~CIfrOrderedList () {
1208 gCurrentQuestion
= NULL
;
1211 VOID
SetMaxContainers (IN UINT8 MaxContainers
) {
1212 mOrderedList
->MaxContainers
= MaxContainers
;
1215 EFI_VFR_RETURN_CODE
SetFlags (IN UINT8 HFlags
, IN UINT8 LFlags
) {
1216 EFI_VFR_RETURN_CODE Ret
;
1218 Ret
= CIfrQuestionHeader::SetFlags (HFlags
);
1219 if (Ret
!= VFR_RETURN_SUCCESS
) {
1223 if (_FLAG_TEST_AND_CLEAR (LFlags
, EFI_IFR_UNIQUE_SET
)) {
1224 mOrderedList
->Flags
|= EFI_IFR_UNIQUE_SET
;
1227 if (_FLAG_TEST_AND_CLEAR (LFlags
, EFI_IFR_NO_EMPTY_SET
)) {
1228 mOrderedList
->Flags
|= EFI_IFR_NO_EMPTY_SET
;
1231 return _FLAGS_ZERO (LFlags
) ? VFR_RETURN_SUCCESS
: VFR_RETURN_FLAGS_UNSUPPORTED
;
1235 class CIfrTime
: public CIfrObj
, public CIfrOpHeader
, public CIfrQuestionHeader
{
1237 EFI_IFR_TIME
*mTime
;
1240 CIfrTime () : CIfrObj (EFI_IFR_TIME_OP
, (CHAR8
**)&mTime
),
1241 CIfrOpHeader (EFI_IFR_TIME_OP
, &mTime
->Header
),
1242 CIfrQuestionHeader (&mTime
->Question
) {
1246 EFI_VFR_RETURN_CODE
SetFlags (IN UINT8 HFlags
, IN UINT8 LFlags
) {
1247 EFI_VFR_RETURN_CODE Ret
;
1249 Ret
= CIfrQuestionHeader::SetFlags (HFlags
);
1250 if (Ret
!= VFR_RETURN_SUCCESS
) {
1254 if (_FLAG_TEST_AND_CLEAR (LFlags
, QF_TIME_HOUR_SUPPRESS
)) {
1255 mTime
->Flags
|= QF_TIME_HOUR_SUPPRESS
;
1258 if (_FLAG_TEST_AND_CLEAR (LFlags
, QF_TIME_MINUTE_SUPPRESS
)) {
1259 mTime
->Flags
|= QF_TIME_MINUTE_SUPPRESS
;
1262 if (_FLAG_TEST_AND_CLEAR (LFlags
, QF_TIME_SECOND_SUPPRESS
)) {
1263 mTime
->Flags
|= QF_TIME_SECOND_SUPPRESS
;
1266 if (_FLAG_TEST_AND_CLEAR (LFlags
, QF_TIME_STORAGE_NORMAL
)) {
1267 mTime
->Flags
|= QF_TIME_STORAGE_NORMAL
;
1268 } else if (_FLAG_TEST_AND_CLEAR (LFlags
, QF_TIME_STORAGE_TIME
)) {
1269 mTime
->Flags
|= QF_TIME_STORAGE_TIME
;
1270 } else if (_FLAG_TEST_AND_CLEAR (LFlags
, QF_TIME_STORAGE_WAKEUP
)) {
1271 mTime
->Flags
|= QF_TIME_STORAGE_WAKEUP
;
1274 return _FLAGS_ZERO (LFlags
) ? VFR_RETURN_SUCCESS
: VFR_RETURN_FLAGS_UNSUPPORTED
;
1278 class CIfrDisableIf
: public CIfrObj
, public CIfrOpHeader
{
1280 EFI_IFR_DISABLE_IF
*mDisableIf
;
1283 CIfrDisableIf () : CIfrObj (EFI_IFR_DISABLE_IF_OP
, (CHAR8
**)&mDisableIf
),
1284 mDisableIf ((EFI_IFR_DISABLE_IF
*) GetObjBinAddr()),
1285 CIfrOpHeader (EFI_IFR_DISABLE_IF_OP
, &mDisableIf
->Header
) {}
1288 class CIfrSuppressIf
: public CIfrObj
, public CIfrOpHeader
{
1290 EFI_IFR_SUPPRESS_IF
*mSuppressIf
;
1293 CIfrSuppressIf () : CIfrObj (EFI_IFR_SUPPRESS_IF_OP
, (CHAR8
**)&mSuppressIf
),
1294 CIfrOpHeader (EFI_IFR_SUPPRESS_IF_OP
, &mSuppressIf
->Header
) {}
1297 class CIfrGrayOutIf
: public CIfrObj
, public CIfrOpHeader
{
1299 EFI_IFR_GRAY_OUT_IF
*mGrayOutIf
;
1302 CIfrGrayOutIf () : CIfrObj (EFI_IFR_GRAY_OUT_IF_OP
, (CHAR8
**)&mGrayOutIf
),
1303 CIfrOpHeader (EFI_IFR_GRAY_OUT_IF_OP
, &mGrayOutIf
->Header
) {}
1306 class CIfrInconsistentIf
: public CIfrObj
, public CIfrOpHeader
{
1308 EFI_IFR_INCONSISTENT_IF
*mInconsistentIf
;
1311 CIfrInconsistentIf () : CIfrObj (EFI_IFR_INCONSISTENT_IF_OP
, (CHAR8
**)&mInconsistentIf
),
1312 CIfrOpHeader (EFI_IFR_INCONSISTENT_IF_OP
, &mInconsistentIf
->Header
) {
1313 mInconsistentIf
->Error
= EFI_STRING_ID_INVALID
;
1316 VOID
SetError (IN EFI_STRING_ID Error
) {
1317 mInconsistentIf
->Error
= Error
;
1321 class CIfrNoSubmitIf
: public CIfrObj
, public CIfrOpHeader
{
1323 EFI_IFR_NO_SUBMIT_IF
*mNoSubmitIf
;
1326 CIfrNoSubmitIf () : CIfrObj (EFI_IFR_NO_SUBMIT_IF_OP
, (CHAR8
**)&mNoSubmitIf
),
1327 CIfrOpHeader (EFI_IFR_NO_SUBMIT_IF_OP
, &mNoSubmitIf
->Header
) {
1328 mNoSubmitIf
->Error
= EFI_STRING_ID_INVALID
;
1331 VOID
SetError (IN EFI_STRING_ID Error
) {
1332 mNoSubmitIf
->Error
= Error
;
1336 class CIfrRefresh
: public CIfrObj
, public CIfrOpHeader
{
1338 EFI_IFR_REFRESH
*mRefresh
;
1341 CIfrRefresh () : CIfrObj (EFI_IFR_REFRESH_OP
, (CHAR8
**)&mRefresh
),
1342 CIfrOpHeader (EFI_IFR_REFRESH_OP
, &mRefresh
->Header
) {
1343 mRefresh
->RefreshInterval
= 0;
1346 VOID
SetRefreshInterval (IN UINT8 RefreshInterval
) {
1347 mRefresh
->RefreshInterval
= RefreshInterval
;
1351 class CIfrVarStoreDevice
: public CIfrObj
, public CIfrOpHeader
{
1353 EFI_IFR_VARSTORE_DEVICE
*mVarStoreDevice
;
1356 CIfrVarStoreDevice () : CIfrObj (EFI_IFR_VARSTORE_DEVICE_OP
, (CHAR8
**)&mVarStoreDevice
),
1357 CIfrOpHeader (EFI_IFR_VARSTORE_DEVICE_OP
, &mVarStoreDevice
->Header
) {
1358 mVarStoreDevice
->DevicePath
= EFI_STRING_ID_INVALID
;
1361 VOID
SetDevicePath (IN EFI_STRING_ID DevicePath
) {
1362 mVarStoreDevice
->DevicePath
= DevicePath
;
1366 class CIfrOneOfOption
: public CIfrObj
, public CIfrOpHeader
{
1368 EFI_IFR_ONE_OF_OPTION
*mOneOfOption
;
1371 CIfrOneOfOption () : CIfrObj (EFI_IFR_ONE_OF_OPTION_OP
, (CHAR8
**)&mOneOfOption
),
1372 CIfrOpHeader (EFI_IFR_ONE_OF_OPTION_OP
, &mOneOfOption
->Header
) {
1373 mOneOfOption
->Flags
= 0;
1374 mOneOfOption
->Option
= EFI_STRING_ID_INVALID
;
1375 mOneOfOption
->Type
= EFI_IFR_TYPE_OTHER
;
1376 memset (&mOneOfOption
->Value
, 0, sizeof (mOneOfOption
->Value
));
1379 VOID
SetOption (IN EFI_STRING_ID Option
) {
1380 mOneOfOption
->Option
= Option
;
1383 EFI_VFR_RETURN_CODE
SetFlags (IN UINT8 LFlags
) {
1384 if (_FLAG_TEST_AND_CLEAR (LFlags
, EFI_IFR_OPTION_DEFAULT
)) {
1385 mOneOfOption
->Flags
|= EFI_IFR_OPTION_DEFAULT
;
1388 if (_FLAG_TEST_AND_CLEAR (LFlags
, EFI_IFR_OPTION_DEFAULT_MFG
)) {
1389 mOneOfOption
->Flags
|= EFI_IFR_OPTION_DEFAULT_MFG
;
1392 if (_IS_EQUAL (LFlags
, EFI_IFR_TYPE_NUM_SIZE_8
)) {
1393 _FLAG_CLEAR (LFlags
, EFI_IFR_TYPE_NUM_SIZE_8
);
1394 mOneOfOption
->Flags
|= EFI_IFR_TYPE_NUM_SIZE_8
;
1395 } else if (_IS_EQUAL (LFlags
, EFI_IFR_TYPE_NUM_SIZE_16
)) {
1396 _FLAG_CLEAR (LFlags
, EFI_IFR_TYPE_NUM_SIZE_16
);
1397 mOneOfOption
->Flags
|= EFI_IFR_TYPE_NUM_SIZE_16
;
1398 } else if (_IS_EQUAL (LFlags
, EFI_IFR_TYPE_NUM_SIZE_32
)) {
1399 _FLAG_CLEAR (LFlags
, EFI_IFR_TYPE_NUM_SIZE_32
);
1400 mOneOfOption
->Flags
|= EFI_IFR_TYPE_NUM_SIZE_32
;
1401 } else if (_IS_EQUAL (LFlags
, EFI_IFR_TYPE_NUM_SIZE_64
)) {
1402 _FLAG_CLEAR (LFlags
, EFI_IFR_TYPE_NUM_SIZE_64
);
1403 mOneOfOption
->Flags
|= EFI_IFR_TYPE_NUM_SIZE_64
;
1404 } else if (_IS_EQUAL (LFlags
, EFI_IFR_TYPE_BOOLEAN
)) {
1405 _FLAG_CLEAR (LFlags
, EFI_IFR_TYPE_BOOLEAN
);
1406 mOneOfOption
->Flags
|= EFI_IFR_TYPE_BOOLEAN
;
1407 } else if (_IS_EQUAL (LFlags
, EFI_IFR_TYPE_TIME
)) {
1408 _FLAG_CLEAR (LFlags
, EFI_IFR_TYPE_TIME
);
1409 mOneOfOption
->Flags
|= EFI_IFR_TYPE_TIME
;
1410 } else if (_IS_EQUAL (LFlags
, EFI_IFR_TYPE_DATE
)) {
1411 _FLAG_CLEAR (LFlags
, EFI_IFR_TYPE_DATE
);
1412 mOneOfOption
->Flags
|= EFI_IFR_TYPE_DATE
;
1413 } else if (_IS_EQUAL (LFlags
, EFI_IFR_TYPE_STRING
)) {
1414 _FLAG_CLEAR (LFlags
, EFI_IFR_TYPE_STRING
);
1415 mOneOfOption
->Flags
|= EFI_IFR_TYPE_STRING
;
1416 } else if (_IS_EQUAL (LFlags
, EFI_IFR_TYPE_OTHER
)) {
1417 _FLAG_CLEAR (LFlags
, EFI_IFR_TYPE_OTHER
);
1418 mOneOfOption
->Flags
|= EFI_IFR_TYPE_OTHER
;
1421 return _FLAGS_ZERO (LFlags
) ? VFR_RETURN_SUCCESS
: VFR_RETURN_FLAGS_UNSUPPORTED
;
1424 VOID
SetType (IN UINT8 Type
) {
1425 mOneOfOption
->Type
= Type
;
1428 VOID
SetValue (IN EFI_IFR_TYPE_VALUE Value
) {
1429 mOneOfOption
->Value
= Value
;
1432 UINT8
GetFlags (VOID
) {
1433 return mOneOfOption
->Flags
;
1437 static EFI_GUID IfrTianoGuid
= EFI_IFR_TIANO_GUID
;
1439 class CIfrClass
: public CIfrObj
, public CIfrOpHeader
{
1441 EFI_IFR_GUID_CLASS
*mClass
;
1444 CIfrClass () : CIfrObj (EFI_IFR_GUID_OP
, (CHAR8
**)&mClass
, sizeof (EFI_IFR_GUID_CLASS
)),
1445 CIfrOpHeader (EFI_IFR_GUID_OP
, &mClass
->Header
, sizeof (EFI_IFR_GUID_CLASS
)) {
1446 mClass
->ExtendOpCode
= EFI_IFR_EXTEND_OP_CLASS
;
1447 mClass
->Guid
= IfrTianoGuid
;
1448 mClass
->Class
= EFI_NON_DEVICE_CLASS
;
1451 VOID
SetClass (IN UINT16 Class
) {
1452 mClass
->Class
= Class
;
1456 class CIfrSubClass
: public CIfrObj
, public CIfrOpHeader
{
1458 EFI_IFR_GUID_SUBCLASS
*mSubClass
;
1461 CIfrSubClass () : CIfrObj (EFI_IFR_GUID_OP
, (CHAR8
**)&mSubClass
, sizeof (EFI_IFR_GUID_SUBCLASS
)),
1462 CIfrOpHeader (EFI_IFR_GUID_OP
, &mSubClass
->Header
, sizeof (EFI_IFR_GUID_SUBCLASS
)) {
1463 mSubClass
->ExtendOpCode
= EFI_IFR_EXTEND_OP_SUBCLASS
;
1464 mSubClass
->Guid
= IfrTianoGuid
;
1465 mSubClass
->SubClass
= EFI_SETUP_APPLICATION_SUBCLASS
;
1468 VOID
SetSubClass (IN UINT16 SubClass
) {
1469 mSubClass
->SubClass
= SubClass
;
1473 class CIfrLabel
: public CIfrObj
, public CIfrOpHeader
{
1475 EFI_IFR_GUID_LABEL
*mLabel
;
1478 CIfrLabel () : CIfrObj (EFI_IFR_GUID_OP
, (CHAR8
**)&mLabel
, sizeof (EFI_IFR_GUID_LABEL
)),
1479 CIfrOpHeader (EFI_IFR_GUID_OP
, &mLabel
->Header
, sizeof (EFI_IFR_GUID_LABEL
)) {
1480 mLabel
->ExtendOpCode
= EFI_IFR_EXTEND_OP_LABEL
;
1481 mLabel
->Guid
= IfrTianoGuid
;
1484 VOID
SetNumber (IN UINT16 Number
) {
1485 mLabel
->Number
= Number
;
1489 class CIfrBanner
: public CIfrObj
, public CIfrOpHeader
{
1491 EFI_IFR_GUID_BANNER
*mBanner
;
1494 CIfrBanner () : CIfrObj (EFI_IFR_GUID_OP
, (CHAR8
**)&mBanner
, sizeof (EFI_IFR_GUID_BANNER
)),
1495 CIfrOpHeader (EFI_IFR_GUID_OP
, &mBanner
->Header
, sizeof (EFI_IFR_GUID_BANNER
)) {
1496 mBanner
->ExtendOpCode
= EFI_IFR_EXTEND_OP_BANNER
;
1497 mBanner
->Guid
= IfrTianoGuid
;
1500 VOID
SetTitle (IN EFI_STRING_ID StringId
) {
1501 mBanner
->Title
= StringId
;
1504 VOID
SetLine (IN UINT16 Line
) {
1505 mBanner
->LineNumber
= Line
;
1508 VOID
SetAlign (IN UINT8 Align
) {
1509 mBanner
->Alignment
= Align
;
1513 class CIfrTimeout
: public CIfrObj
, public CIfrOpHeader
{
1515 EFI_IFR_GUID_TIMEOUT
*mTimeout
;
1518 CIfrTimeout (IN UINT16 Timeout
= 0) : CIfrObj (EFI_IFR_GUID_OP
, (CHAR8
**)&mTimeout
, sizeof (EFI_IFR_GUID_TIMEOUT
)),
1519 CIfrOpHeader (EFI_IFR_GUID_OP
, &mTimeout
->Header
, sizeof (EFI_IFR_GUID_TIMEOUT
)) {
1520 mTimeout
->ExtendOpCode
= EFI_IFR_EXTEND_OP_TIMEOUT
;
1521 mTimeout
->Guid
= IfrTianoGuid
;
1522 mTimeout
->TimeOut
= Timeout
;
1525 VOID
SetTimeout (IN UINT16 Timeout
) {
1526 mTimeout
->TimeOut
= Timeout
;
1530 class CIfrDup
: public CIfrObj
, public CIfrOpHeader
{
1537 ) : CIfrObj (EFI_IFR_DUP_OP
, (CHAR8
**)&mDup
),
1538 CIfrOpHeader (EFI_IFR_DUP_OP
, &mDup
->Header
) {
1543 class CIfrEqIdId
: public CIfrObj
, public CIfrOpHeader
{
1545 EFI_IFR_EQ_ID_ID
*mEqIdId
;
1550 ) : CIfrObj (EFI_IFR_EQ_ID_ID_OP
, (CHAR8
**)&mEqIdId
),
1551 CIfrOpHeader (EFI_IFR_EQ_ID_ID_OP
, &mEqIdId
->Header
) {
1553 mEqIdId
->QuestionId1
= EFI_QUESTION_ID_INVALID
;
1554 mEqIdId
->QuestionId2
= EFI_QUESTION_ID_INVALID
;
1557 VOID
SetQuestionId1 (
1558 IN EFI_QUESTION_ID QuestionId
,
1562 if (QuestionId
!= EFI_QUESTION_ID_INVALID
) {
1563 mEqIdId
->QuestionId1
= QuestionId
;
1565 gCFormPkg
.AssignPending (VarIdStr
, (VOID
*)(&mEqIdId
->QuestionId1
), sizeof (EFI_QUESTION_ID
), LineNo
, NO_QST_REFED
);
1569 VOID
SetQuestionId2 (
1570 IN EFI_QUESTION_ID QuestionId
,
1574 if (QuestionId
!= EFI_QUESTION_ID_INVALID
) {
1575 mEqIdId
->QuestionId2
= QuestionId
;
1577 gCFormPkg
.AssignPending (VarIdStr
, (VOID
*)(&mEqIdId
->QuestionId2
), sizeof (EFI_QUESTION_ID
), LineNo
, NO_QST_REFED
);
1582 class CIfrEqIdVal
: public CIfrObj
, public CIfrOpHeader
{
1584 EFI_IFR_EQ_ID_VAL
*mEqIdVal
;
1589 ) : CIfrObj (EFI_IFR_EQ_ID_VAL_OP
, (CHAR8
**)&mEqIdVal
),
1590 CIfrOpHeader (EFI_IFR_EQ_ID_VAL_OP
, &mEqIdVal
->Header
) {
1592 mEqIdVal
->QuestionId
= EFI_QUESTION_ID_INVALID
;
1595 VOID
SetQuestionId (
1596 IN EFI_QUESTION_ID QuestionId
,
1600 if (QuestionId
!= EFI_QUESTION_ID_INVALID
) {
1601 mEqIdVal
->QuestionId
= QuestionId
;
1603 gCFormPkg
.AssignPending (VarIdStr
, (VOID
*)(&mEqIdVal
->QuestionId
), sizeof (EFI_QUESTION_ID
), LineNo
, NO_QST_REFED
);
1607 VOID
SetValue (IN UINT16 Value
) {
1608 mEqIdVal
->Value
= Value
;
1612 class CIfrEqIdList
: public CIfrObj
, public CIfrOpHeader
{
1614 EFI_IFR_EQ_ID_LIST
*mEqIdVList
;
1619 ) : CIfrObj (EFI_IFR_EQ_ID_LIST_OP
, (CHAR8
**)&mEqIdVList
, sizeof (EFI_IFR_EQ_ID_LIST
), TRUE
),
1620 CIfrOpHeader (EFI_IFR_EQ_ID_LIST_OP
, &mEqIdVList
->Header
) {
1622 mEqIdVList
->QuestionId
= EFI_QUESTION_ID_INVALID
;
1623 mEqIdVList
->ListLength
= 0;
1624 mEqIdVList
->ValueList
[0] = 0;
1627 VOID
SetQuestionId (
1628 IN EFI_QUESTION_ID QuestionId
,
1632 if (QuestionId
!= EFI_QUESTION_ID_INVALID
) {
1633 mEqIdVList
->QuestionId
= QuestionId
;
1635 gCFormPkg
.AssignPending (VarIdStr
, (VOID
*)(&mEqIdVList
->QuestionId
), sizeof (EFI_QUESTION_ID
), LineNo
, NO_QST_REFED
);
1639 VOID
SetListLength (IN UINT16 ListLength
) {
1640 mEqIdVList
->ListLength
= ListLength
;
1643 VOID
SetValueList (IN UINT16 Index
, IN UINT16 Value
) {
1645 mEqIdVList
->ValueList
[0] = Value
;
1649 if (ExpendObjBin (sizeof (UINT16
)) ==TRUE
) {
1650 IncLength (sizeof (UINT16
));
1651 mEqIdVList
->ValueList
[Index
] = Value
;
1656 class CIfrQuestionRef1
: public CIfrObj
, public CIfrOpHeader
{
1658 EFI_IFR_QUESTION_REF1
*mQuestionRef1
;
1663 ) : CIfrObj (EFI_IFR_QUESTION_REF1_OP
, (CHAR8
**)&mQuestionRef1
),
1664 CIfrOpHeader (EFI_IFR_QUESTION_REF1_OP
, &mQuestionRef1
->Header
) {
1666 mQuestionRef1
->QuestionId
= EFI_QUESTION_ID_INVALID
;
1669 VOID
SetQuestionId (
1670 IN EFI_QUESTION_ID QuestionId
,
1674 if (QuestionId
!= EFI_QUESTION_ID_INVALID
) {
1675 mQuestionRef1
->QuestionId
= QuestionId
;
1677 gCFormPkg
.AssignPending (VarIdStr
, (VOID
*)(&mQuestionRef1
->QuestionId
), sizeof (EFI_QUESTION_ID
), LineNo
, NO_QST_REFED
);
1682 class CIfrQuestionRef2
: public CIfrObj
, public CIfrOpHeader
{
1684 EFI_IFR_QUESTION_REF2
*mQuestionRef2
;
1689 ) : CIfrObj (EFI_IFR_QUESTION_REF2_OP
, (CHAR8
**)&mQuestionRef2
),
1690 CIfrOpHeader (EFI_IFR_QUESTION_REF2_OP
, &mQuestionRef2
->Header
) {
1695 class CIfrQuestionRef3
: public CIfrObj
, public CIfrOpHeader
{
1697 EFI_IFR_QUESTION_REF3
*mQuestionRef3
;
1702 ) : CIfrObj (EFI_IFR_QUESTION_REF3_OP
, (CHAR8
**)&mQuestionRef3
),
1703 CIfrOpHeader (EFI_IFR_QUESTION_REF3_OP
, &mQuestionRef3
->Header
) {
1708 class CIfrQuestionRef3_2
: public CIfrObj
, public CIfrOpHeader
{
1710 EFI_IFR_QUESTION_REF3_2
*mQuestionRef3_2
;
1713 CIfrQuestionRef3_2 (
1715 ) : CIfrObj (EFI_IFR_QUESTION_REF3_OP
, (CHAR8
**)&mQuestionRef3_2
, sizeof (EFI_IFR_QUESTION_REF3_2
)),
1716 CIfrOpHeader (EFI_IFR_QUESTION_REF3_OP
, &mQuestionRef3_2
->Header
, sizeof (EFI_IFR_QUESTION_REF3_2
)) {
1718 mQuestionRef3_2
->DevicePath
= EFI_STRING_ID_INVALID
;
1721 VOID
SetDevicePath (IN EFI_STRING_ID DevicePath
) {
1722 mQuestionRef3_2
->DevicePath
= DevicePath
;
1726 class CIfrQuestionRef3_3
: public CIfrObj
, public CIfrOpHeader
{
1728 EFI_IFR_QUESTION_REF3_3
*mQuestionRef3_3
;
1731 CIfrQuestionRef3_3 (
1733 ) : CIfrObj (EFI_IFR_QUESTION_REF3_OP
, (CHAR8
**)&mQuestionRef3_3
, sizeof (EFI_IFR_QUESTION_REF3_3
)),
1734 CIfrOpHeader (EFI_IFR_QUESTION_REF3_OP
, &mQuestionRef3_3
->Header
, sizeof (EFI_IFR_QUESTION_REF3_3
)) {
1736 mQuestionRef3_3
->DevicePath
= EFI_STRING_ID_INVALID
;
1737 memset (&mQuestionRef3_3
->Guid
, 0, sizeof (EFI_GUID
));
1740 VOID
SetDevicePath (IN EFI_STRING_ID DevicePath
) {
1741 mQuestionRef3_3
->DevicePath
= DevicePath
;
1744 VOID
SetGuid (IN EFI_GUID
*Guid
) {
1745 mQuestionRef3_3
->Guid
= *Guid
;
1749 class CIfrRuleRef
: public CIfrObj
, public CIfrOpHeader
{
1751 EFI_IFR_RULE_REF
*mRuleRef
;
1756 ) : CIfrObj (EFI_IFR_RULE_REF_OP
, (CHAR8
**)&mRuleRef
),
1757 CIfrOpHeader (EFI_IFR_RULE_REF_OP
, &mRuleRef
->Header
) {
1759 mRuleRef
->RuleId
= EFI_RULE_ID_INVALID
;
1762 VOID
SetRuleId (IN UINT8 RuleId
) {
1763 mRuleRef
->RuleId
= RuleId
;
1767 class CIfrStringRef1
: public CIfrObj
, public CIfrOpHeader
{
1769 EFI_IFR_STRING_REF1
*mStringRef1
;
1774 ) : CIfrObj (EFI_IFR_STRING_REF1_OP
, (CHAR8
**)&mStringRef1
),
1775 CIfrOpHeader (EFI_IFR_STRING_REF1_OP
, &mStringRef1
->Header
) {
1777 mStringRef1
->StringId
= EFI_STRING_ID_INVALID
;
1780 VOID
SetStringId (IN EFI_STRING_ID StringId
) {
1781 mStringRef1
->StringId
= StringId
;
1785 class CIfrStringRef2
: public CIfrObj
, public CIfrOpHeader
{
1787 EFI_IFR_STRING_REF2
*mStringRef2
;
1792 ) : CIfrObj (EFI_IFR_STRING_REF2_OP
, (CHAR8
**)&mStringRef2
),
1793 CIfrOpHeader (EFI_IFR_STRING_REF2_OP
, &mStringRef2
->Header
) {
1798 class CIfrThis
: public CIfrObj
, public CIfrOpHeader
{
1800 EFI_IFR_THIS
*mThis
;
1805 ) : CIfrObj (EFI_IFR_THIS_OP
, (CHAR8
**)&mThis
),
1806 CIfrOpHeader (EFI_IFR_THIS_OP
, &mThis
->Header
) {
1811 class CIfrUint8
: public CIfrObj
, public CIfrOpHeader
{
1813 EFI_IFR_UINT8
*mUint8
;
1818 ) : CIfrObj (EFI_IFR_UINT8_OP
, (CHAR8
**)&mUint8
),
1819 CIfrOpHeader (EFI_IFR_UINT8_OP
, &mUint8
->Header
) {
1823 VOID
SetValue (IN UINT8 Value
) {
1824 mUint8
->Value
= Value
;
1828 class CIfrUint16
: public CIfrObj
, public CIfrOpHeader
{
1830 EFI_IFR_UINT16
*mUint16
;
1835 ) : CIfrObj (EFI_IFR_UINT16_OP
, (CHAR8
**)&mUint16
),
1836 CIfrOpHeader (EFI_IFR_UINT16_OP
, &mUint16
->Header
) {
1840 VOID
SetValue (IN UINT16 Value
) {
1841 mUint16
->Value
= Value
;
1845 class CIfrUint32
: public CIfrObj
, public CIfrOpHeader
{
1847 EFI_IFR_UINT32
*mUint32
;
1852 ) : CIfrObj (EFI_IFR_UINT32_OP
, (CHAR8
**)&mUint32
),
1853 CIfrOpHeader (EFI_IFR_UINT32_OP
, &mUint32
->Header
) {
1857 VOID
SetValue (IN UINT32 Value
) {
1858 mUint32
->Value
= Value
;
1862 class CIfrUint64
: public CIfrObj
, public CIfrOpHeader
{
1864 EFI_IFR_UINT64
*mUint64
;
1869 ) : CIfrObj (EFI_IFR_UINT64_OP
, (CHAR8
**)&mUint64
),
1870 CIfrOpHeader (EFI_IFR_UINT64_OP
, &mUint64
->Header
) {
1874 VOID
SetValue (IN UINT64 Value
) {
1875 mUint64
->Value
= Value
;
1879 class CIfrTrue
: public CIfrObj
, public CIfrOpHeader
{
1881 EFI_IFR_TRUE
*mTrue
;
1886 ) : CIfrObj (EFI_IFR_TRUE_OP
, (CHAR8
**)&mTrue
),
1887 CIfrOpHeader (EFI_IFR_TRUE_OP
, &mTrue
->Header
) {
1892 class CIfrFalse
: public CIfrObj
, public CIfrOpHeader
{
1894 EFI_IFR_FALSE
*mFalse
;
1899 ) : CIfrObj (EFI_IFR_FALSE_OP
, (CHAR8
**)&mFalse
),
1900 CIfrOpHeader (EFI_IFR_FALSE_OP
, &mFalse
->Header
) {
1905 class CIfrOne
: public CIfrObj
, public CIfrOpHeader
{
1912 ) : CIfrObj (EFI_IFR_ONE_OP
, (CHAR8
**)&mOne
),
1913 CIfrOpHeader (EFI_IFR_ONE_OP
, &mOne
->Header
) {
1918 class CIfrOnes
: public CIfrObj
, public CIfrOpHeader
{
1920 EFI_IFR_ONES
*mOnes
;
1925 ) : CIfrObj (EFI_IFR_ONES_OP
, (CHAR8
**)&mOnes
),
1926 CIfrOpHeader (EFI_IFR_ONES_OP
, &mOnes
->Header
) {
1931 class CIfrZero
: public CIfrObj
, public CIfrOpHeader
{
1933 EFI_IFR_ZERO
*mZero
;
1938 ) : CIfrObj (EFI_IFR_ZERO_OP
, (CHAR8
**)&mZero
),
1939 CIfrOpHeader (EFI_IFR_ZERO_OP
, &mZero
->Header
) {
1944 class CIfrUndefined
: public CIfrObj
, public CIfrOpHeader
{
1946 EFI_IFR_UNDEFINED
*mUndefined
;
1951 ) : CIfrObj (EFI_IFR_UNDEFINED_OP
, (CHAR8
**)&mUndefined
),
1952 CIfrOpHeader (EFI_IFR_UNDEFINED_OP
, &mUndefined
->Header
) {
1957 class CIfrVersion
: public CIfrObj
, public CIfrOpHeader
{
1959 EFI_IFR_VERSION
*mVersion
;
1964 ) : CIfrObj (EFI_IFR_VERSION_OP
, (CHAR8
**)&mVersion
),
1965 CIfrOpHeader (EFI_IFR_VERSION_OP
, &mVersion
->Header
) {
1970 class CIfrLength
: public CIfrObj
, public CIfrOpHeader
{
1972 EFI_IFR_LENGTH
*mLength
;
1977 ) : CIfrObj (EFI_IFR_LENGTH_OP
, (CHAR8
**)&mLength
),
1978 CIfrOpHeader (EFI_IFR_LENGTH_OP
, &mLength
->Header
) {
1983 class CIfrNot
: public CIfrObj
, public CIfrOpHeader
{
1990 ) : CIfrObj (EFI_IFR_NOT_OP
, (CHAR8
**)&mNot
),
1991 CIfrOpHeader (EFI_IFR_NOT_OP
, &mNot
->Header
) {
1996 class CIfrBitWiseNot
: public CIfrObj
, public CIfrOpHeader
{
1998 EFI_IFR_BITWISE_NOT
*mBitWise
;
2003 ) : CIfrObj (EFI_IFR_BITWISE_NOT_OP
, (CHAR8
**)&mBitWise
),
2004 CIfrOpHeader (EFI_IFR_BITWISE_NOT_OP
, &mBitWise
->Header
) {
2009 class CIfrToBoolean
: public CIfrObj
, public CIfrOpHeader
{
2011 EFI_IFR_TO_BOOLEAN
*mToBoolean
;
2016 ) : CIfrObj (EFI_IFR_TO_BOOLEAN_OP
, (CHAR8
**)&mToBoolean
),
2017 CIfrOpHeader (EFI_IFR_TO_BOOLEAN_OP
, &mToBoolean
->Header
) {
2022 class CIfrToString
: public CIfrObj
, public CIfrOpHeader
{
2024 EFI_IFR_TO_STRING
*mToString
;
2029 ) : CIfrObj (EFI_IFR_TO_STRING_OP
, (CHAR8
**)&mToString
),
2030 CIfrOpHeader (EFI_IFR_TO_STRING_OP
, &mToString
->Header
) {
2034 VOID
SetFormat (IN UINT8 Format
) {
2035 mToString
->Format
= Format
;
2039 class CIfrToUint
: public CIfrObj
, public CIfrOpHeader
{
2041 EFI_IFR_TO_UINT
*mToUint
;
2046 ) : CIfrObj (EFI_IFR_TO_UINT_OP
, (CHAR8
**)&mToUint
),
2047 CIfrOpHeader (EFI_IFR_TO_UINT_OP
, &mToUint
->Header
) {
2052 class CIfrToUpper
: public CIfrObj
, public CIfrOpHeader
{
2054 EFI_IFR_TO_UPPER
*mToUpper
;
2059 ) : CIfrObj (EFI_IFR_TO_UPPER_OP
, (CHAR8
**)&mToUpper
),
2060 CIfrOpHeader (EFI_IFR_TO_UPPER_OP
, &mToUpper
->Header
) {
2065 class CIfrToLower
: public CIfrObj
, public CIfrOpHeader
{
2067 EFI_IFR_TO_LOWER
*mToLower
;
2072 ) : CIfrObj (EFI_IFR_TO_LOWER_OP
, (CHAR8
**)&mToLower
),
2073 CIfrOpHeader (EFI_IFR_TO_LOWER_OP
, &mToLower
->Header
) {
2078 class CIfrAdd
: public CIfrObj
, public CIfrOpHeader
{
2085 ) : CIfrObj (EFI_IFR_ADD_OP
, (CHAR8
**)&mAdd
),
2086 CIfrOpHeader (EFI_IFR_ADD_OP
, &mAdd
->Header
) {
2091 class CIfrBitWiseAnd
: public CIfrObj
, public CIfrOpHeader
{
2093 EFI_IFR_BITWISE_AND
*mBitWiseAnd
;
2098 ) : CIfrObj (EFI_IFR_BITWISE_AND_OP
, (CHAR8
**)&mBitWiseAnd
),
2099 CIfrOpHeader (EFI_IFR_BITWISE_AND_OP
, &mBitWiseAnd
->Header
) {
2104 class CIfrBitWiseOr
: public CIfrObj
, public CIfrOpHeader
{
2106 EFI_IFR_BITWISE_OR
*mBitWiseOr
;
2111 ) : CIfrObj (EFI_IFR_BITWISE_OR_OP
, (CHAR8
**)&mBitWiseOr
),
2112 CIfrOpHeader (EFI_IFR_BITWISE_OR_OP
, &mBitWiseOr
->Header
) {
2117 class CIfrAnd
: public CIfrObj
, public CIfrOpHeader
{
2124 ) : CIfrObj (EFI_IFR_AND_OP
, (CHAR8
**)&mAnd
),
2125 CIfrOpHeader (EFI_IFR_AND_OP
, &mAnd
->Header
) {
2130 class CIfrCatenate
: public CIfrObj
, public CIfrOpHeader
{
2132 EFI_IFR_CATENATE
*mCatenate
;
2137 ) : CIfrObj (EFI_IFR_CATENATE_OP
, (CHAR8
**)&mCatenate
),
2138 CIfrOpHeader (EFI_IFR_CATENATE_OP
, &mCatenate
->Header
) {
2143 class CIfrDivide
: public CIfrObj
, public CIfrOpHeader
{
2145 EFI_IFR_DIVIDE
*mDivide
;
2150 ) : CIfrObj (EFI_IFR_DIVIDE_OP
, (CHAR8
**)&mDivide
),
2151 CIfrOpHeader (EFI_IFR_DIVIDE_OP
, &mDivide
->Header
) {
2156 class CIfrEqual
: public CIfrObj
, public CIfrOpHeader
{
2158 EFI_IFR_EQUAL
*mEqual
;
2163 ) : CIfrObj (EFI_IFR_EQUAL_OP
, (CHAR8
**)&mEqual
),
2164 CIfrOpHeader (EFI_IFR_EQUAL_OP
, &mEqual
->Header
) {
2169 class CIfrGreaterEqual
: public CIfrObj
, public CIfrOpHeader
{
2171 EFI_IFR_GREATER_EQUAL
*mGreaterEqual
;
2176 ) : CIfrObj (EFI_IFR_GREATER_EQUAL_OP
, (CHAR8
**)&mGreaterEqual
),
2177 CIfrOpHeader (EFI_IFR_GREATER_EQUAL_OP
, &mGreaterEqual
->Header
) {
2182 class CIfrGreaterThan
: public CIfrObj
, public CIfrOpHeader
{
2184 EFI_IFR_GREATER_THAN
*mGreaterThan
;
2189 ) : CIfrObj (EFI_IFR_GREATER_THAN_OP
, (CHAR8
**)&mGreaterThan
),
2190 CIfrOpHeader (EFI_IFR_GREATER_THAN_OP
, &mGreaterThan
->Header
) {
2195 class CIfrLessEqual
: public CIfrObj
, public CIfrOpHeader
{
2197 EFI_IFR_LESS_EQUAL
*mLessEqual
;
2202 ) : CIfrObj (EFI_IFR_LESS_EQUAL_OP
, (CHAR8
**)&mLessEqual
),
2203 CIfrOpHeader (EFI_IFR_LESS_EQUAL_OP
, &mLessEqual
->Header
) {
2208 class CIfrLessThan
: public CIfrObj
, public CIfrOpHeader
{
2210 EFI_IFR_LESS_THAN
*mLessThan
;
2215 ) : CIfrObj (EFI_IFR_LESS_THAN_OP
, (CHAR8
**)&mLessThan
),
2216 CIfrOpHeader (EFI_IFR_LESS_THAN_OP
, &mLessThan
->Header
) {
2221 class CIfrMatch
: public CIfrObj
, public CIfrOpHeader
{
2223 EFI_IFR_MATCH
*mMatch
;
2228 ) : CIfrObj (EFI_IFR_MATCH_OP
, (CHAR8
**)&mMatch
),
2229 CIfrOpHeader (EFI_IFR_MATCH_OP
, &mMatch
->Header
) {
2234 class CIfrMultiply
: public CIfrObj
, public CIfrOpHeader
{
2236 EFI_IFR_MULTIPLY
*mMultiply
;
2241 ) : CIfrObj (EFI_IFR_MULTIPLY_OP
, (CHAR8
**)&mMultiply
),
2242 CIfrOpHeader (EFI_IFR_MULTIPLY_OP
, &mMultiply
->Header
) {
2247 class CIfrModulo
: public CIfrObj
, public CIfrOpHeader
{
2249 EFI_IFR_MODULO
*mModulo
;
2254 ) : CIfrObj (EFI_IFR_MODULO_OP
, (CHAR8
**)&mModulo
),
2255 CIfrOpHeader (EFI_IFR_MODULO_OP
, &mModulo
->Header
) {
2260 class CIfrNotEqual
: public CIfrObj
, public CIfrOpHeader
{
2262 EFI_IFR_NOT_EQUAL
*mNotEqual
;
2267 ) : CIfrObj (EFI_IFR_NOT_EQUAL_OP
, (CHAR8
**)&mNotEqual
),
2268 CIfrOpHeader (EFI_IFR_NOT_EQUAL_OP
, &mNotEqual
->Header
) {
2273 class CIfrOr
: public CIfrObj
, public CIfrOpHeader
{
2280 ) : CIfrObj (EFI_IFR_OR_OP
, (CHAR8
**)&mOr
),
2281 CIfrOpHeader (EFI_IFR_OR_OP
, &mOr
->Header
) {
2286 class CIfrShiftLeft
: public CIfrObj
, public CIfrOpHeader
{
2288 EFI_IFR_SHIFT_LEFT
*mShiftLeft
;
2293 ) : CIfrObj (EFI_IFR_SHIFT_LEFT_OP
, (CHAR8
**)&mShiftLeft
),
2294 CIfrOpHeader (EFI_IFR_SHIFT_LEFT_OP
, &mShiftLeft
->Header
) {
2299 class CIfrShiftRight
: public CIfrObj
, public CIfrOpHeader
{
2301 EFI_IFR_SHIFT_RIGHT
*mShiftRight
;
2306 ) : CIfrObj (EFI_IFR_SHIFT_RIGHT_OP
, (CHAR8
**)&mShiftRight
),
2307 CIfrOpHeader (EFI_IFR_SHIFT_RIGHT_OP
, &mShiftRight
->Header
) {
2312 class CIfrSubtract
: public CIfrObj
, public CIfrOpHeader
{
2314 EFI_IFR_SUBTRACT
*mSubtract
;
2319 ) : CIfrObj (EFI_IFR_SUBTRACT_OP
, (CHAR8
**)&mSubtract
),
2320 CIfrOpHeader (EFI_IFR_SUBTRACT_OP
, &mSubtract
->Header
) {
2325 class CIfrConditional
: public CIfrObj
, public CIfrOpHeader
{
2327 EFI_IFR_CONDITIONAL
*mConditional
;
2332 ) : CIfrObj (EFI_IFR_CONDITIONAL_OP
, (CHAR8
**)&mConditional
),
2333 CIfrOpHeader (EFI_IFR_CONDITIONAL_OP
, &mConditional
->Header
) {
2338 class CIfrFind
: public CIfrObj
, public CIfrOpHeader
{
2340 EFI_IFR_FIND
*mFind
;
2345 ) : CIfrObj (EFI_IFR_FIND_OP
, (CHAR8
**)&mFind
),
2346 CIfrOpHeader (EFI_IFR_FIND_OP
, &mFind
->Header
) {
2350 VOID
SetFormat (IN UINT8 Format
) {
2351 mFind
->Format
= Format
;
2355 class CIfrMid
: public CIfrObj
, public CIfrOpHeader
{
2362 ) : CIfrObj (EFI_IFR_MID_OP
, (CHAR8
**)&mMid
),
2363 CIfrOpHeader (EFI_IFR_MID_OP
, &mMid
->Header
) {
2368 class CIfrToken
: public CIfrObj
, public CIfrOpHeader
{
2370 EFI_IFR_TOKEN
*mToken
;
2375 ) : CIfrObj (EFI_IFR_TOKEN_OP
, (CHAR8
**)&mToken
),
2376 CIfrOpHeader (EFI_IFR_TOKEN_OP
, &mToken
->Header
) {
2381 class CIfrSpan
: public CIfrObj
, public CIfrOpHeader
{
2383 EFI_IFR_SPAN
*mSpan
;
2388 ) : CIfrObj (EFI_IFR_SPAN_OP
, (CHAR8
**)&mSpan
),
2389 CIfrOpHeader (EFI_IFR_SPAN_OP
, &mSpan
->Header
) {
2391 mSpan
->Flags
= EFI_IFR_FLAGS_FIRST_MATCHING
;
2394 EFI_VFR_RETURN_CODE
SetFlags (IN UINT8 LFlags
) {
2395 if (_IS_EQUAL (LFlags
, EFI_IFR_FLAGS_FIRST_MATCHING
)) {
2396 mSpan
->Flags
|= EFI_IFR_FLAGS_FIRST_MATCHING
;
2397 } else if (_FLAG_TEST_AND_CLEAR (LFlags
, EFI_IFR_FLAGS_FIRST_NON_MATCHING
)) {
2398 mSpan
->Flags
|= EFI_IFR_FLAGS_FIRST_NON_MATCHING
;
2401 return _FLAGS_ZERO (LFlags
) ? VFR_RETURN_SUCCESS
: VFR_RETURN_FLAGS_UNSUPPORTED
;