3 The definition of CFormPkg's member function
5 Copyright (c) 2004 - 2017, Intel Corporation. All rights reserved.<BR>
6 This program and the accompanying materials
7 are licensed and made available under the terms and conditions of the BSD License
8 which accompanies this distribution. The full text of the license may be found at
9 http://opensource.org/licenses/bsd-license.php
11 THE PROGRAM IS DISTRIBUTED UNDER THE BSD LICENSE ON AN "AS IS" BASIS,
12 WITHOUT WARRANTIES OR REPRESENTATIONS OF ANY KIND, EITHER EXPRESS OR IMPLIED.
16 #ifndef _EFIIFRCLASS_H_
17 #define _EFIIFRCLASS_H_
22 #include "VfrUtilityLib.h"
24 #define NO_QST_REFED "no question refered"
32 * The functions below are used for flags setting
34 static inline BOOLEAN
_FLAGS_ZERO (
41 static inline VOID
_FLAG_CLEAR (
49 static inline UINT8
_FLAG_TEST_AND_CLEAR (
54 UINT8 Ret
= Flags
& Mask
;
59 static inline UINT8
_IS_EQUAL (
64 return Flags
== Value
;
68 * The definition of CIfrBin
75 struct SPendingAssign
{
76 CHAR8
*mKey
; // key ! unique
82 struct SPendingAssign
*mNext
;
84 SPendingAssign (IN CHAR8
*, IN VOID
*, IN UINT32
, IN UINT32
, IN CONST CHAR8
*);
87 VOID
SetAddrAndLen (IN VOID
*, IN UINT32
);
88 VOID
AssignValue (IN VOID
*, IN UINT32
);
89 CHAR8
* GetKey (VOID
);
92 SPendingAssign (IN CONST SPendingAssign
&); // Prevent copy-construction
93 SPendingAssign
& operator= (IN CONST SPendingAssign
&); // Prevent assignment
100 struct SBufferNode
*mNext
;
104 BOOLEAN CompatibleMode
;
105 EFI_GUID
*OverrideClassGuid
;
106 } INPUT_INFO_TO_SYNTAX
;
111 SBufferNode
*mBufferNodeQueueHead
;
112 SBufferNode
*mBufferNodeQueueTail
;
113 SBufferNode
*mCurrBufferNode
;
115 SBufferNode
*mReadBufferNode
;
116 UINT32 mReadBufferOffset
;
120 VOID
_WRITE_PKG_LINE (IN
FILE *, IN UINT32
, IN CONST CHAR8
*, IN CHAR8
*, IN UINT32
);
121 VOID
_WRITE_PKG_END (IN
FILE *, IN UINT32
, IN CONST CHAR8
*, IN CHAR8
*, IN UINT32
);
122 SBufferNode
* GetBinBufferNodeForAddr (IN CHAR8
*);
123 SBufferNode
* CreateNewNode ();
124 SBufferNode
* GetNodeBefore (IN SBufferNode
*);
125 EFI_VFR_RETURN_CODE
InsertNodeBefore (IN SBufferNode
*, IN SBufferNode
*);
128 SPendingAssign
*PendingAssignList
;
131 CFormPkg (IN UINT32 BufferSize
= 4096);
134 CHAR8
* IfrBinBufferGet (IN UINT32
);
135 inline UINT32
GetPkgLength (VOID
);
138 UINT32
Read (IN CHAR8
*, IN UINT32
);
141 EFI_VFR_RETURN_CODE
BuildPkgHdr (OUT EFI_HII_PACKAGE_HEADER
**);
142 EFI_VFR_RETURN_CODE
BuildPkg (IN
FILE *, IN PACKAGE_DATA
*PkgData
= NULL
);
143 EFI_VFR_RETURN_CODE
BuildPkg (OUT PACKAGE_DATA
&);
144 EFI_VFR_RETURN_CODE
GenCFile (IN CHAR8
*, IN
FILE *, IN PACKAGE_DATA
*PkgData
= NULL
);
147 CFormPkg (IN CONST CFormPkg
&); // Prevent copy-construction
148 CFormPkg
& operator= (IN CONST CFormPkg
&); // Prevent assignment
151 EFI_VFR_RETURN_CODE
AssignPending (IN CHAR8
*, IN VOID
*, IN UINT32
, IN UINT32
, IN CONST CHAR8
*Msg
= NULL
);
152 VOID
DoPendingAssign (IN CHAR8
*, IN VOID
*, IN UINT32
);
153 bool HavePendingUnassigned (VOID
);
154 VOID
PendingAssignPrintAll (VOID
);
155 EFI_VFR_RETURN_CODE
DeclarePendingQuestion (
156 IN CVfrVarDataTypeDB
&lCVfrVarDataTypeDB
,
157 IN CVfrDataStorage
&lCVfrDataStorage
,
158 IN CVfrQuestionDB
&lCVfrQuestionDB
,
159 IN EFI_GUID
*LocalFormSetGuid
,
161 OUT CHAR8
**InsertOpcodeAddr
163 EFI_VFR_RETURN_CODE
AdjustDynamicInsertOpcode (
164 IN CHAR8
*LastFormEndAddr
,
165 IN CHAR8
*InsertOpcodeAddr
,
166 IN BOOLEAN CreateOpcodeAfterParsingVfr
168 CHAR8
* GetBufAddrBaseOnOffset (
173 extern CFormPkg gCFormPkg
;
174 extern CVfrStringDB gCVfrStringDB
;
175 extern UINT32 gAdjustOpcodeOffset
;
176 extern BOOLEAN gNeedAdjustOpcode
;
190 #define EFI_IFR_RECORDINFO_IDX_INVALUD 0xFFFFFF
191 #define EFI_IFR_RECORDINFO_IDX_START 0x0
192 #define EFI_HII_MAX_SUPPORT_DEFAULT_TYPE 0x08
194 struct QuestionDefaultRecord
{
195 BOOLEAN mIsDefaultIdExist
[EFI_HII_MAX_SUPPORT_DEFAULT_TYPE
]; // Record the default id in mAllDefaultIdArray[EFI_HII_MAX_SUPPORT_DEFAULT_TYPE]
196 // whether exists in current question.
198 SIfrRecord
*mDefaultValueRecord
; // Point to the default value record in RecordList which has smallest default Id.
199 // (for checkbox it may be NULL, because the dedault value is always true when the flag is set.)
201 BOOLEAN mIsDefaultOpcode
; // whether the default value with smallest default id is given by default opcode.
202 // (for oneof and checkbox default info may be given by flag.)
204 UINT16 mDefaultNumber
; // The default number of this question.
207 class CIfrRecordInfoDB
{
211 SIfrRecord
*mIfrRecordListHead
;
212 SIfrRecord
*mIfrRecordListTail
;
213 UINT8 mAllDefaultTypeCount
;
214 UINT16 mAllDefaultIdArray
[EFI_HII_MAX_SUPPORT_DEFAULT_TYPE
];
216 SIfrRecord
* GetRecordInfoFromIdx (IN UINT32
);
217 BOOLEAN
CheckQuestionOpCode (IN UINT8
);
218 BOOLEAN
CheckIdOpCode (IN UINT8
);
219 EFI_QUESTION_ID
GetOpcodeQuestionId (IN EFI_IFR_OP_HEADER
*);
221 CIfrRecordInfoDB (VOID
);
222 ~CIfrRecordInfoDB (VOID
);
224 inline VOID
TurnOn (VOID
) {
228 inline VOID
TurnOff (VOID
) {
232 SIfrRecord
* GetRecordInfoFromOffset (IN UINT32
);
233 VOID
IfrAdjustOffsetForRecord (VOID
);
234 BOOLEAN
IfrAdjustDynamicOpcodeInRecords (IN BOOLEAN
);
236 UINT32
IfrRecordRegister (IN UINT32
, IN CHAR8
*, IN UINT8
, IN UINT32
);
237 VOID
IfrRecordInfoUpdate (IN UINT32
, IN UINT32
, IN CHAR8
*, IN UINT8
, IN UINT32
);
238 VOID
IfrRecordOutput (IN
FILE *, IN UINT32 LineNo
);
239 VOID
IfrRecordOutput (OUT PACKAGE_DATA
&);
240 EFI_VFR_RETURN_CODE
IfrRecordAdjust (VOID
);
241 VOID
IfrUpdateRecordInfoForDynamicOpcode (IN BOOLEAN
);
242 VOID
IfrCheckAddDefaultRecord (IN BOOLEAN
, IN BOOLEAN
);
243 VOID
IfrGetDefaultStoreInfo ();
244 VOID
IfrCreateDefaultRecord (IN UINT8 Size
,IN UINT16 DefaultId
,IN UINT8 Type
,IN UINT32 LineNo
,IN EFI_IFR_TYPE_VALUE Value
);
245 VOID
IfrCreateDefaultForQuestion (IN SIfrRecord
*, IN QuestionDefaultRecord
*);
246 VOID
IfrParseDefaulInfoInQuestion (IN SIfrRecord
*, OUT QuestionDefaultRecord
*);
247 VOID
IfrAddDefaultToBufferConfig (IN UINT16
, IN SIfrRecord
*,IN EFI_IFR_TYPE_VALUE
);
250 CIfrRecordInfoDB (IN CONST CIfrRecordInfoDB
&); // Prevent copy-construction
251 CIfrRecordInfoDB
& operator= (IN CONST CIfrRecordInfoDB
&); // Prevent assignment
254 extern CIfrRecordInfoDB gCIfrRecordInfoDB
;
257 * The definition of CIfrObj
259 extern BOOLEAN gCreateOp
;
272 CIfrObj (IN UINT8 OpCode
, OUT CHAR8
**IfrObj
= NULL
, IN UINT8 ObjBinLen
= 0, IN BOOLEAN DelayEmit
= FALSE
);
273 virtual ~CIfrObj(VOID
);
275 VOID
_EMIT_PENDING_OBJ (VOID
);
277 inline VOID
SetLineNo (IN UINT32 LineNo
) {
281 inline CHAR8
* GetObjBinAddr (VOID
) {
285 inline UINT32
GetObjBinOffset (VOID
) {
289 inline UINT8
GetObjBinLen (VOID
) {
293 inline bool ExpendObjBin (IN UINT8 Size
) {
294 if ((mDelayEmit
== TRUE
) && ((mObjBinLen
+ Size
) > mObjBinLen
)) {
295 mObjBinLen
= mObjBinLen
+ Size
;
302 inline bool ShrinkObjBin (IN UINT8 Size
) {
303 if ((mDelayEmit
== TRUE
) && (mObjBinLen
> Size
)) {
313 * The definition of CIfrOpHeader
317 EFI_IFR_OP_HEADER
*mHeader
;
320 CIfrOpHeader (IN UINT8 OpCode
, IN VOID
*StartAddr
, IN UINT8 Length
= 0);
321 CIfrOpHeader (IN CIfrOpHeader
&);
322 CIfrOpHeader
& operator=(IN CONST CIfrOpHeader
&);
324 VOID
IncLength (UINT8 Size
) {
325 if ((mHeader
->Length
+ Size
) > mHeader
->Length
) {
326 mHeader
->Length
= mHeader
->Length
+ Size
;
330 VOID
DecLength (UINT8 Size
) {
331 if (mHeader
->Length
>= Size
) {
332 mHeader
->Length
-= Size
;
337 return mHeader
->Length
;
341 return mHeader
->Scope
;
344 VOID
SetScope (IN UINT8 Scope
) {
345 mHeader
->Scope
= Scope
;
348 VOID
UpdateHeader (IN EFI_IFR_OP_HEADER
*Header
) {
353 return mHeader
->OpCode
;
357 extern UINT8 gScopeCount
;
360 * The definition of CIfrStatementHeader
362 class CIfrStatementHeader
{
364 EFI_IFR_STATEMENT_HEADER
*mHeader
;
367 CIfrStatementHeader (
368 IN EFI_IFR_STATEMENT_HEADER
*StartAddr
369 ) : mHeader ((EFI_IFR_STATEMENT_HEADER
*)StartAddr
) {
371 mHeader
->Help
= EFI_STRING_ID_INVALID
;
372 mHeader
->Prompt
= EFI_STRING_ID_INVALID
;
375 EFI_IFR_STATEMENT_HEADER
*GetStatementHeader () {
379 VOID
SetPrompt (IN EFI_STRING_ID Prompt
) {
380 mHeader
->Prompt
= Prompt
;
383 VOID
SetHelp (IN EFI_STRING_ID Help
) {
384 mHeader
->Help
= Help
;
389 * The definition of CIfrQuestionHeader
391 #define EFI_IFR_QUESTION_FLAG_DEFAULT 0
393 class CIfrQuestionHeader
: public CIfrStatementHeader
{
395 EFI_IFR_QUESTION_HEADER
*mHeader
;
397 EFI_IFR_STATEMENT_HEADER
* QH2SH (EFI_IFR_QUESTION_HEADER
*Qheader
) {
398 return &(Qheader
)->Header
;
402 EFI_QUESTION_ID
QUESTION_ID (VOID
) {
403 return mHeader
->QuestionId
;
406 EFI_VARSTORE_ID
VARSTORE_ID (VOID
) {
407 return mHeader
->VarStoreId
;
410 VOID
VARSTORE_INFO (OUT EFI_VARSTORE_INFO
*Info
) {
412 Info
->mVarStoreId
= mHeader
->VarStoreId
;
413 memmove (&Info
->mVarStoreId
, &mHeader
->VarStoreInfo
, sizeof (Info
->mVarStoreId
));
418 return mHeader
->Flags
;
423 IN EFI_IFR_QUESTION_HEADER
*StartAddr
,
424 IN UINT8 Flags
= EFI_IFR_QUESTION_FLAG_DEFAULT
425 ) : CIfrStatementHeader (QH2SH(StartAddr
)) {
427 mHeader
->QuestionId
= EFI_QUESTION_ID_INVALID
;
428 mHeader
->VarStoreId
= EFI_VARSTORE_ID_INVALID
;
429 mHeader
->VarStoreInfo
.VarName
= EFI_STRING_ID_INVALID
;
430 mHeader
->VarStoreInfo
.VarOffset
= EFI_VAROFFSET_INVALID
;
431 mHeader
->Flags
= Flags
;
434 VOID
SetQuestionId (IN EFI_QUESTION_ID QuestionId
) {
435 mHeader
->QuestionId
= QuestionId
;
438 VOID
SetVarStoreInfo (IN EFI_VARSTORE_INFO
*Info
) {
439 mHeader
->VarStoreId
= Info
->mVarStoreId
;
440 mHeader
->VarStoreInfo
.VarName
= Info
->mInfo
.mVarName
;
441 mHeader
->VarStoreInfo
.VarOffset
= Info
->mInfo
.mVarOffset
;
444 EFI_VFR_RETURN_CODE
SetFlags (IN UINT8 Flags
) {
445 if (_FLAG_TEST_AND_CLEAR (Flags
, EFI_IFR_FLAG_READ_ONLY
)) {
446 mHeader
->Flags
|= EFI_IFR_FLAG_READ_ONLY
;
449 _FLAG_CLEAR (Flags
, 0x02);
451 if (_FLAG_TEST_AND_CLEAR (Flags
, EFI_IFR_FLAG_CALLBACK
)) {
452 mHeader
->Flags
|= EFI_IFR_FLAG_CALLBACK
;
456 // ignore NVAccessFlag
458 _FLAG_CLEAR (Flags
, 0x08);
460 if (_FLAG_TEST_AND_CLEAR (Flags
, EFI_IFR_FLAG_RESET_REQUIRED
)) {
461 mHeader
->Flags
|= EFI_IFR_FLAG_RESET_REQUIRED
;
464 if (_FLAG_TEST_AND_CLEAR (Flags
, EFI_IFR_FLAG_RECONNECT_REQUIRED
)) {
465 mHeader
->Flags
|= EFI_IFR_FLAG_RECONNECT_REQUIRED
;
469 // Set LateCheck Flag to compatible for framework flag
470 // but it uses 0x20 as its flag, if in the future UEFI may take this flag
472 if (_FLAG_TEST_AND_CLEAR (Flags
, 0x20)) {
473 mHeader
->Flags
|= 0x20;
476 if (_FLAG_TEST_AND_CLEAR (Flags
, EFI_IFR_FLAG_OPTIONS_ONLY
)) {
477 mHeader
->Flags
|= EFI_IFR_FLAG_OPTIONS_ONLY
;
480 return _FLAGS_ZERO (Flags
) ? VFR_RETURN_SUCCESS
: VFR_RETURN_FLAGS_UNSUPPORTED
;
483 VOID
UpdateCIfrQuestionHeader (IN EFI_IFR_QUESTION_HEADER
*Header
) {
489 * The definition of CIfrMinMaxStepData
491 class CIfrMinMaxStepData
{
493 MINMAXSTEP_DATA
*mMinMaxStepData
;
498 CIfrMinMaxStepData (MINMAXSTEP_DATA
*DataAddr
, BOOLEAN NumericOpcode
=FALSE
) : mMinMaxStepData (DataAddr
) {
499 mMinMaxStepData
->u64
.MinValue
= 0;
500 mMinMaxStepData
->u64
.MaxValue
= 0;
501 mMinMaxStepData
->u64
.Step
= 0;
503 IsNumeric
= NumericOpcode
;
506 VOID
SetMinMaxStepData (IN UINT64 MinValue
, IN UINT64 MaxValue
, IN UINT64 Step
) {
508 mMinMaxStepData
->u64
.MinValue
= MinValue
;
509 mMinMaxStepData
->u64
.MaxValue
= MaxValue
;
512 if (MinValue
< mMinMaxStepData
->u64
.MinValue
) {
513 mMinMaxStepData
->u64
.MinValue
= MinValue
;
515 if (MaxValue
> mMinMaxStepData
->u64
.MaxValue
) {
516 mMinMaxStepData
->u64
.MaxValue
= MaxValue
;
519 mMinMaxStepData
->u64
.Step
= Step
;
522 VOID
SetMinMaxStepData (IN UINT32 MinValue
, IN UINT32 MaxValue
, IN UINT32 Step
) {
524 mMinMaxStepData
->u32
.MinValue
= MinValue
;
525 mMinMaxStepData
->u32
.MaxValue
= MaxValue
;
528 if (MinValue
< mMinMaxStepData
->u32
.MinValue
) {
529 mMinMaxStepData
->u32
.MinValue
= MinValue
;
531 if (MaxValue
> mMinMaxStepData
->u32
.MaxValue
) {
532 mMinMaxStepData
->u32
.MaxValue
= MaxValue
;
535 mMinMaxStepData
->u32
.Step
= Step
;
538 VOID
SetMinMaxStepData (IN UINT16 MinValue
, IN UINT16 MaxValue
, IN UINT16 Step
) {
540 mMinMaxStepData
->u16
.MinValue
= MinValue
;
541 mMinMaxStepData
->u16
.MaxValue
= MaxValue
;
544 if (MinValue
< mMinMaxStepData
->u16
.MinValue
) {
545 mMinMaxStepData
->u16
.MinValue
= MinValue
;
547 if (MaxValue
> mMinMaxStepData
->u16
.MaxValue
) {
548 mMinMaxStepData
->u16
.MaxValue
= MaxValue
;
551 mMinMaxStepData
->u16
.Step
= Step
;
554 VOID
SetMinMaxStepData (IN UINT8 MinValue
, IN UINT8 MaxValue
, IN UINT8 Step
) {
556 mMinMaxStepData
->u8
.MinValue
= MinValue
;
557 mMinMaxStepData
->u8
.MaxValue
= MaxValue
;
560 if (MinValue
< mMinMaxStepData
->u8
.MinValue
) {
561 mMinMaxStepData
->u8
.MinValue
= MinValue
;
563 if (MaxValue
> mMinMaxStepData
->u8
.MaxValue
) {
564 mMinMaxStepData
->u8
.MaxValue
= MaxValue
;
567 mMinMaxStepData
->u8
.Step
= Step
;
570 UINT64
GetMinData (UINT8 VarType
, BOOLEAN IsBitVar
) {
573 MinValue
= mMinMaxStepData
->u32
.MinValue
;
577 case EFI_IFR_TYPE_NUM_SIZE_64
:
578 MinValue
= mMinMaxStepData
->u64
.MinValue
;
580 case EFI_IFR_TYPE_NUM_SIZE_32
:
581 MinValue
= (UINT64
) mMinMaxStepData
->u32
.MinValue
;
583 case EFI_IFR_TYPE_NUM_SIZE_16
:
584 MinValue
= (UINT64
) mMinMaxStepData
->u16
.MinValue
;
586 case EFI_IFR_TYPE_NUM_SIZE_8
:
587 MinValue
= (UINT64
) mMinMaxStepData
->u8
.MinValue
;
595 UINT64
GetMaxData (UINT8 VarType
, BOOLEAN IsBitVar
) {
598 MaxValue
= mMinMaxStepData
->u32
.MaxValue
;
602 case EFI_IFR_TYPE_NUM_SIZE_64
:
603 MaxValue
= mMinMaxStepData
->u64
.MaxValue
;
605 case EFI_IFR_TYPE_NUM_SIZE_32
:
606 MaxValue
= (UINT64
) mMinMaxStepData
->u32
.MaxValue
;
608 case EFI_IFR_TYPE_NUM_SIZE_16
:
609 MaxValue
= (UINT64
) mMinMaxStepData
->u16
.MaxValue
;
611 case EFI_IFR_TYPE_NUM_SIZE_8
:
612 MaxValue
= (UINT64
) mMinMaxStepData
->u8
.MaxValue
;
620 UINT64
GetStepData (UINT8 VarType
, BOOLEAN IsBitVar
) {
623 MaxValue
= mMinMaxStepData
->u32
.Step
;
627 case EFI_IFR_TYPE_NUM_SIZE_64
:
628 MaxValue
= mMinMaxStepData
->u64
.Step
;
630 case EFI_IFR_TYPE_NUM_SIZE_32
:
631 MaxValue
= (UINT64
) mMinMaxStepData
->u32
.Step
;
633 case EFI_IFR_TYPE_NUM_SIZE_16
:
634 MaxValue
= (UINT64
) mMinMaxStepData
->u16
.Step
;
636 case EFI_IFR_TYPE_NUM_SIZE_8
:
637 MaxValue
= (UINT64
) mMinMaxStepData
->u8
.Step
;
645 BOOLEAN
IsNumericOpcode () {
649 VOID
UpdateCIfrMinMaxStepData (IN MINMAXSTEP_DATA
*MinMaxStepData
) {
650 mMinMaxStepData
= MinMaxStepData
;
654 static CIfrQuestionHeader
*gCurrentQuestion
= NULL
;
655 static CIfrMinMaxStepData
*gCurrentMinMaxData
= NULL
;
656 static BOOLEAN gIsOrderedList
= FALSE
;
657 static BOOLEAN gIsStringOp
= FALSE
;
660 * The definition of all of the UEFI IFR Objects
662 class CIfrFormSet
: public CIfrObj
, public CIfrOpHeader
{
664 EFI_IFR_FORM_SET
*mFormSet
;
665 EFI_GUID
*mClassGuid
;
668 CIfrFormSet (UINT8 Size
) : CIfrObj (EFI_IFR_FORM_SET_OP
, (CHAR8
**)&mFormSet
, Size
),
669 CIfrOpHeader (EFI_IFR_FORM_SET_OP
, &mFormSet
->Header
, Size
) {
670 mFormSet
->Help
= EFI_STRING_ID_INVALID
;
671 mFormSet
->FormSetTitle
= EFI_STRING_ID_INVALID
;
673 memset (&mFormSet
->Guid
, 0, sizeof (EFI_GUID
));
674 mClassGuid
= (EFI_GUID
*) (mFormSet
+ 1);
677 VOID
SetGuid (IN EFI_GUID
*Guid
) {
678 memmove (&mFormSet
->Guid
, Guid
, sizeof (EFI_GUID
));
681 VOID
SetFormSetTitle (IN EFI_STRING_ID FormSetTitle
) {
682 mFormSet
->FormSetTitle
= FormSetTitle
;
685 VOID
SetHelp (IN EFI_STRING_ID Help
) {
686 mFormSet
->Help
= Help
;
689 VOID
SetClassGuid (IN EFI_GUID
*Guid
) {
690 memmove (&(mClassGuid
[mFormSet
->Flags
++]), Guid
, sizeof (EFI_GUID
));
694 return mFormSet
->Flags
;
698 class CIfrEnd
: public CIfrObj
, public CIfrOpHeader
{
703 CIfrEnd () : CIfrObj (EFI_IFR_END_OP
, (CHAR8
**)&mEnd
),
704 CIfrOpHeader (EFI_IFR_END_OP
, &mEnd
->Header
) {}
707 class CIfrDefaultStore
: public CIfrObj
, public CIfrOpHeader
{
709 EFI_IFR_DEFAULTSTORE
*mDefaultStore
;
712 CIfrDefaultStore () : CIfrObj (EFI_IFR_DEFAULTSTORE_OP
, (CHAR8
**)&mDefaultStore
),
713 CIfrOpHeader (EFI_IFR_DEFAULTSTORE_OP
, &mDefaultStore
->Header
) {
714 mDefaultStore
->DefaultId
= EFI_VARSTORE_ID_INVALID
;
715 mDefaultStore
->DefaultName
= EFI_STRING_ID_INVALID
;
718 VOID
SetDefaultName (IN EFI_STRING_ID DefaultName
) {
719 mDefaultStore
->DefaultName
= DefaultName
;
722 VOID
SetDefaultId (IN UINT16 DefaultId
) {
723 mDefaultStore
->DefaultId
= DefaultId
;
727 #define EFI_FORM_ID_MAX 0xFFFF
728 #define EFI_FREE_FORM_ID_BITMAP_SIZE ((EFI_FORM_ID_MAX + 1) / EFI_BITS_PER_UINT32)
732 STATIC UINT32 FormIdBitMap
[EFI_FREE_FORM_ID_BITMAP_SIZE
];
734 STATIC BOOLEAN
ChekFormIdFree (IN EFI_FORM_ID FormId
) {
735 UINT32 Index
= (FormId
/ EFI_BITS_PER_UINT32
);
736 UINT32 Offset
= (FormId
% EFI_BITS_PER_UINT32
);
738 return (FormIdBitMap
[Index
] & (0x80000000 >> Offset
)) == 0;
741 STATIC VOID
MarkFormIdUsed (IN EFI_FORM_ID FormId
) {
742 UINT32 Index
= (FormId
/ EFI_BITS_PER_UINT32
);
743 UINT32 Offset
= (FormId
% EFI_BITS_PER_UINT32
);
745 FormIdBitMap
[Index
] |= (0x80000000 >> Offset
);
749 class CIfrForm
: public CIfrObj
, public CIfrOpHeader
{
754 CIfrForm () : CIfrObj (EFI_IFR_FORM_OP
, (CHAR8
**)&mForm
),
755 CIfrOpHeader (EFI_IFR_FORM_OP
, &mForm
->Header
) {
757 mForm
->FormTitle
= EFI_STRING_ID_INVALID
;
760 EFI_VFR_RETURN_CODE
SetFormId (IN EFI_FORM_ID FormId
) {
763 // FormId can't be 0.
765 return VFR_RETURN_INVALID_PARAMETER
;
767 if (CIfrFormId::ChekFormIdFree (FormId
) == FALSE
) {
768 return VFR_RETURN_FORMID_REDEFINED
;
770 mForm
->FormId
= FormId
;
771 CIfrFormId::MarkFormIdUsed (FormId
);
772 return VFR_RETURN_SUCCESS
;
775 VOID
SetFormTitle (IN EFI_STRING_ID FormTitle
) {
776 mForm
->FormTitle
= FormTitle
;
780 class CIfrFormMap
: public CIfrObj
, public CIfrOpHeader
{
782 EFI_IFR_FORM_MAP
*mFormMap
;
783 EFI_IFR_FORM_MAP_METHOD
*mMethodMap
;
786 CIfrFormMap () : CIfrObj (EFI_IFR_FORM_MAP_OP
, (CHAR8
**)&mFormMap
, sizeof (EFI_IFR_FORM_MAP
), TRUE
),
787 CIfrOpHeader (EFI_IFR_FORM_MAP_OP
, &mFormMap
->Header
) {
788 mFormMap
->FormId
= 0;
789 mMethodMap
= (EFI_IFR_FORM_MAP_METHOD
*) (mFormMap
+ 1);
792 EFI_VFR_RETURN_CODE
SetFormId (IN EFI_FORM_ID FormId
) {
795 // FormId can't be 0.
797 return VFR_RETURN_INVALID_PARAMETER
;
799 if (CIfrFormId::ChekFormIdFree (FormId
) == FALSE
) {
800 return VFR_RETURN_FORMID_REDEFINED
;
802 mFormMap
->FormId
= FormId
;
803 CIfrFormId::MarkFormIdUsed (FormId
);
804 return VFR_RETURN_SUCCESS
;
807 VOID
SetFormMapMethod (IN EFI_STRING_ID MethodTitle
, IN EFI_GUID
*MethodGuid
) {
808 if (ExpendObjBin (sizeof (EFI_IFR_FORM_MAP_METHOD
))) {
809 IncLength (sizeof (EFI_IFR_FORM_MAP_METHOD
));
811 mMethodMap
->MethodTitle
= MethodTitle
;
812 memmove (&(mMethodMap
->MethodIdentifier
), MethodGuid
, sizeof (EFI_GUID
));
818 class CIfrVarStore
: public CIfrObj
, public CIfrOpHeader
{
820 EFI_IFR_VARSTORE
*mVarStore
;
823 CIfrVarStore () : CIfrObj (EFI_IFR_VARSTORE_OP
, (CHAR8
**)&mVarStore
, sizeof (EFI_IFR_VARSTORE
), TRUE
),
824 CIfrOpHeader (EFI_IFR_VARSTORE_OP
, &mVarStore
->Header
) {
825 mVarStore
->VarStoreId
= EFI_VARSTORE_ID_INVALID
;
827 memset (&mVarStore
->Guid
, 0, sizeof (EFI_GUID
));
828 mVarStore
->Name
[0] = '\0';
831 VOID
SetGuid (IN EFI_GUID
*Guid
) {
832 memmove (&mVarStore
->Guid
, Guid
, sizeof (EFI_GUID
));
835 VOID
SetVarStoreId (IN EFI_VARSTORE_ID VarStoreId
) {
836 mVarStore
->VarStoreId
= VarStoreId
;
839 VOID
SetSize (IN UINT16 Size
) {
840 mVarStore
->Size
= Size
;
843 VOID
SetName (IN CHAR8
*Name
) {
847 Len
= (UINT8
) strlen (Name
);
849 if (ExpendObjBin (Len
) == TRUE
) {
851 strcpy ((CHAR8
*)(mVarStore
->Name
), Name
);
858 class CIfrVarStoreEfi
: public CIfrObj
, public CIfrOpHeader
{
860 EFI_IFR_VARSTORE_EFI
*mVarStoreEfi
;
863 CIfrVarStoreEfi () : CIfrObj (EFI_IFR_VARSTORE_EFI_OP
, (CHAR8
**)&mVarStoreEfi
, sizeof (EFI_IFR_VARSTORE_EFI
), TRUE
),
864 CIfrOpHeader (EFI_IFR_VARSTORE_EFI_OP
, &mVarStoreEfi
->Header
) {
865 mVarStoreEfi
->VarStoreId
= EFI_VAROFFSET_INVALID
;
866 mVarStoreEfi
->Size
= 0;
867 memset (&mVarStoreEfi
->Guid
, 0, sizeof (EFI_GUID
));
868 mVarStoreEfi
->Name
[0] = '\0';
871 VOID
SetGuid (IN EFI_GUID
*Guid
) {
872 memmove (&mVarStoreEfi
->Guid
, Guid
, sizeof (EFI_GUID
));
875 VOID
SetVarStoreId (IN UINT16 VarStoreId
) {
876 mVarStoreEfi
->VarStoreId
= VarStoreId
;
879 VOID
SetAttributes (IN UINT32 Attributes
) {
880 mVarStoreEfi
->Attributes
= Attributes
;
882 VOID
SetSize (IN UINT16 Size
) {
883 mVarStoreEfi
->Size
= Size
;
886 VOID
SetName (IN CHAR8
*Name
) {
890 Len
= (UINT8
) strlen (Name
);
892 if (ExpendObjBin (Len
) == TRUE
) {
894 strcpy ((CHAR8
*)(mVarStoreEfi
->Name
), Name
);
900 VOID
SetBinaryLength (IN UINT16 Size
) {
903 Len
= sizeof (EFI_IFR_VARSTORE_EFI
);
905 ExpendObjBin(Size
- Len
);
906 IncLength(Size
- Len
);
908 ShrinkObjBin(Len
- Size
);
909 DecLength(Len
- Size
);
914 class CIfrVarStoreNameValue
: public CIfrObj
, public CIfrOpHeader
{
916 EFI_IFR_VARSTORE_NAME_VALUE
*mVarStoreNameValue
;
919 CIfrVarStoreNameValue () : CIfrObj (EFI_IFR_VARSTORE_NAME_VALUE_OP
, (CHAR8
**)&mVarStoreNameValue
),
920 CIfrOpHeader (EFI_IFR_VARSTORE_NAME_VALUE_OP
, &mVarStoreNameValue
->Header
) {
921 mVarStoreNameValue
->VarStoreId
= EFI_VAROFFSET_INVALID
;
922 memset (&mVarStoreNameValue
->Guid
, 0, sizeof (EFI_GUID
));
925 VOID
SetGuid (IN EFI_GUID
*Guid
) {
926 memmove (&mVarStoreNameValue
->Guid
, Guid
, sizeof (EFI_GUID
));
929 VOID
SetVarStoreId (IN UINT16 VarStoreId
) {
930 mVarStoreNameValue
->VarStoreId
= VarStoreId
;
934 class CIfrImage
: public CIfrObj
, public CIfrOpHeader
{
936 EFI_IFR_IMAGE
*mImage
;
939 CIfrImage () : CIfrObj (EFI_IFR_IMAGE_OP
, (CHAR8
**)&mImage
),
940 CIfrOpHeader (EFI_IFR_IMAGE_OP
, &mImage
->Header
) {
941 mImage
->Id
= EFI_IMAGE_ID_INVALID
;
944 VOID
SetImageId (IN EFI_IMAGE_ID ImageId
) {
945 mImage
->Id
= ImageId
;
949 class CIfrModal
: public CIfrObj
, public CIfrOpHeader
{
951 EFI_IFR_MODAL_TAG
*mModal
;
954 CIfrModal () : CIfrObj (EFI_IFR_MODAL_TAG_OP
, (CHAR8
**)&mModal
),
955 CIfrOpHeader (EFI_IFR_MODAL_TAG_OP
, &mModal
->Header
) {
960 class CIfrLocked
: public CIfrObj
, public CIfrOpHeader
{
962 EFI_IFR_LOCKED
*mLocked
;
965 CIfrLocked () : CIfrObj (EFI_IFR_LOCKED_OP
, (CHAR8
**)&mLocked
),
966 CIfrOpHeader (EFI_IFR_LOCKED_OP
, &mLocked
->Header
) {}
969 class CIfrRule
: public CIfrObj
, public CIfrOpHeader
{
974 CIfrRule () : CIfrObj (EFI_IFR_RULE_OP
, (CHAR8
**)&mRule
),
975 mRule ((EFI_IFR_RULE
*)GetObjBinAddr()),
976 CIfrOpHeader (EFI_IFR_RULE_OP
, &mRule
->Header
) {
977 mRule
->RuleId
= EFI_RULE_ID_INVALID
;
980 VOID
SetRuleId (IN UINT8 RuleId
) {
981 mRule
->RuleId
= RuleId
;
985 static EFI_IFR_TYPE_VALUE gZeroEfiIfrTypeValue
= {0, };
987 class CIfrDefault
: public CIfrObj
, public CIfrOpHeader
{
989 EFI_IFR_DEFAULT
*mDefault
;
994 IN UINT16 DefaultId
= EFI_HII_DEFAULT_CLASS_STANDARD
,
995 IN UINT8 Type
= EFI_IFR_TYPE_OTHER
,
996 IN EFI_IFR_TYPE_VALUE Value
= gZeroEfiIfrTypeValue
997 ) : CIfrObj (EFI_IFR_DEFAULT_OP
, (CHAR8
**)&mDefault
, Size
),
998 CIfrOpHeader (EFI_IFR_DEFAULT_OP
, &mDefault
->Header
, Size
) {
999 mDefault
->Type
= Type
;
1000 mDefault
->DefaultId
= DefaultId
;
1001 memmove (&(mDefault
->Value
), &Value
, Size
- OFFSET_OF (EFI_IFR_DEFAULT
, Value
));
1004 VOID
SetDefaultId (IN UINT16 DefaultId
) {
1005 mDefault
->DefaultId
= DefaultId
;
1008 VOID
SetType (IN UINT8 Type
) {
1009 mDefault
->Type
= Type
;
1012 VOID
SetValue (IN EFI_IFR_TYPE_VALUE Value
) {
1013 memmove (&mDefault
->Value
, &Value
, mDefault
->Header
.Length
- OFFSET_OF (EFI_IFR_DEFAULT
, Value
));
1017 class CIfrDefault2
: public CIfrObj
, public CIfrOpHeader
{
1019 EFI_IFR_DEFAULT_2
*mDefault
;
1023 IN UINT16 DefaultId
= EFI_HII_DEFAULT_CLASS_STANDARD
,
1024 IN UINT8 Type
= EFI_IFR_TYPE_OTHER
1025 ) : CIfrObj (EFI_IFR_DEFAULT_OP
, (CHAR8
**)&mDefault
, sizeof (EFI_IFR_DEFAULT_2
)),
1026 CIfrOpHeader (EFI_IFR_DEFAULT_OP
, &mDefault
->Header
, sizeof (EFI_IFR_DEFAULT_2
)) {
1027 mDefault
->Type
= Type
;
1028 mDefault
->DefaultId
= DefaultId
;
1031 VOID
SetDefaultId (IN UINT16 DefaultId
) {
1032 mDefault
->DefaultId
= DefaultId
;
1035 VOID
SetType (IN UINT8 Type
) {
1036 mDefault
->Type
= Type
;
1040 class CIfrValue
: public CIfrObj
, public CIfrOpHeader
{
1042 EFI_IFR_VALUE
*mValue
;
1045 CIfrValue () : CIfrObj (EFI_IFR_VALUE_OP
, (CHAR8
**)&mValue
),
1046 CIfrOpHeader (EFI_IFR_VALUE_OP
, &mValue
->Header
) {}
1050 class CIfrRead
: public CIfrObj
, public CIfrOpHeader
{
1052 EFI_IFR_READ
*mRead
;
1055 CIfrRead () : CIfrObj (EFI_IFR_READ_OP
, (CHAR8
**)&mRead
),
1056 CIfrOpHeader (EFI_IFR_READ_OP
, &mRead
->Header
) {}
1060 class CIfrWrite
: public CIfrObj
, public CIfrOpHeader
{
1062 EFI_IFR_WRITE
*mWrite
;
1065 CIfrWrite () : CIfrObj (EFI_IFR_WRITE_OP
, (CHAR8
**)&mWrite
),
1066 CIfrOpHeader (EFI_IFR_WRITE_OP
, &mWrite
->Header
) {}
1070 class CIfrGet
: public CIfrObj
, public CIfrOpHeader
{
1077 ) : CIfrObj (EFI_IFR_GET_OP
, (CHAR8
**)&mGet
),
1078 CIfrOpHeader (EFI_IFR_GET_OP
, &mGet
->Header
) {
1082 VOID
SetVarInfo (IN EFI_VARSTORE_INFO
*Info
) {
1083 mGet
->VarStoreId
= Info
->mVarStoreId
;
1084 mGet
->VarStoreInfo
.VarName
= Info
->mInfo
.mVarName
;
1085 mGet
->VarStoreInfo
.VarOffset
= Info
->mInfo
.mVarOffset
;
1086 mGet
->VarStoreType
= Info
->mVarType
;
1090 class CIfrSet
: public CIfrObj
, public CIfrOpHeader
{
1097 ) : CIfrObj (EFI_IFR_SET_OP
, (CHAR8
**)&mSet
),
1098 CIfrOpHeader (EFI_IFR_SET_OP
, &mSet
->Header
) {
1102 VOID
SetVarInfo (IN EFI_VARSTORE_INFO
*Info
) {
1103 mSet
->VarStoreId
= Info
->mVarStoreId
;
1104 mSet
->VarStoreInfo
.VarName
= Info
->mInfo
.mVarName
;
1105 mSet
->VarStoreInfo
.VarOffset
= Info
->mInfo
.mVarOffset
;
1106 mSet
->VarStoreType
= Info
->mVarType
;
1110 class CIfrSubtitle
: public CIfrObj
, public CIfrOpHeader
, public CIfrStatementHeader
{
1112 EFI_IFR_SUBTITLE
*mSubtitle
;
1115 CIfrSubtitle () : CIfrObj (EFI_IFR_SUBTITLE_OP
, (CHAR8
**)&mSubtitle
),
1116 CIfrOpHeader (EFI_IFR_SUBTITLE_OP
, &mSubtitle
->Header
),
1117 CIfrStatementHeader (&mSubtitle
->Statement
) {
1118 mSubtitle
->Flags
= 0;
1121 EFI_VFR_RETURN_CODE
SetFlags (IN UINT8 LFlags
) {
1122 if (_FLAG_TEST_AND_CLEAR (LFlags
, EFI_IFR_FLAGS_HORIZONTAL
)) {
1123 mSubtitle
->Flags
|= EFI_IFR_FLAGS_HORIZONTAL
;
1126 return _FLAGS_ZERO (LFlags
) ? VFR_RETURN_SUCCESS
: VFR_RETURN_FLAGS_UNSUPPORTED
;
1130 class CIfrText
: public CIfrObj
, public CIfrOpHeader
, public CIfrStatementHeader
{
1132 EFI_IFR_TEXT
*mText
;
1135 CIfrText () : CIfrObj (EFI_IFR_TEXT_OP
, (CHAR8
**)&mText
),
1136 CIfrOpHeader (EFI_IFR_TEXT_OP
, &mText
->Header
),
1137 CIfrStatementHeader (&mText
->Statement
) {
1138 mText
->TextTwo
= EFI_STRING_ID_INVALID
;
1141 VOID
SetTextTwo (IN EFI_STRING_ID StringId
) {
1142 mText
->TextTwo
= StringId
;
1146 class CIfrRef
: public CIfrObj
, public CIfrOpHeader
, public CIfrQuestionHeader
{
1151 CIfrRef () : CIfrObj (EFI_IFR_REF_OP
, (CHAR8
**)&mRef
),
1152 CIfrOpHeader (EFI_IFR_REF_OP
, &mRef
->Header
),
1153 CIfrQuestionHeader (&mRef
->Question
) {
1157 VOID
SetFormId (IN EFI_FORM_ID FormId
) {
1158 mRef
->FormId
= FormId
;
1162 class CIfrRef2
: public CIfrObj
, public CIfrOpHeader
, public CIfrQuestionHeader
{
1164 EFI_IFR_REF2
*mRef2
;
1167 CIfrRef2 () : CIfrObj (EFI_IFR_REF_OP
, (CHAR8
**)&mRef2
, sizeof (EFI_IFR_REF2
)),
1168 CIfrOpHeader (EFI_IFR_REF_OP
, &mRef2
->Header
, sizeof (EFI_IFR_REF2
)),
1169 CIfrQuestionHeader (&mRef2
->Question
) {
1171 mRef2
->QuestionId
= EFI_QUESTION_ID_INVALID
;
1174 VOID
SetFormId (IN EFI_FORM_ID FormId
) {
1175 mRef2
->FormId
= FormId
;
1178 VOID
SetQuestionId (IN EFI_QUESTION_ID QuestionId
) {
1179 mRef2
->QuestionId
= QuestionId
;
1183 class CIfrRef3
: public CIfrObj
, public CIfrOpHeader
, public CIfrQuestionHeader
{
1185 EFI_IFR_REF3
*mRef3
;
1188 CIfrRef3 () : CIfrObj (EFI_IFR_REF_OP
, (CHAR8
**)&mRef3
, sizeof(EFI_IFR_REF3
)),
1189 CIfrOpHeader (EFI_IFR_REF_OP
, &mRef3
->Header
, sizeof (EFI_IFR_REF3
)),
1190 CIfrQuestionHeader (&mRef3
->Question
) {
1192 mRef3
->QuestionId
= EFI_QUESTION_ID_INVALID
;
1193 memset (&mRef3
->FormSetId
, 0, sizeof (EFI_GUID
));
1196 VOID
SetFormId (IN EFI_FORM_ID FormId
) {
1197 mRef3
->FormId
= FormId
;
1200 VOID
SetQuestionId (IN EFI_QUESTION_ID QuestionId
) {
1201 mRef3
->QuestionId
= QuestionId
;
1204 VOID
SetFormSetId (IN EFI_GUID FormSetId
) {
1205 mRef3
->FormSetId
= FormSetId
;
1209 class CIfrRef4
: public CIfrObj
, public CIfrOpHeader
, public CIfrQuestionHeader
{
1211 EFI_IFR_REF4
*mRef4
;
1214 CIfrRef4 () : CIfrObj (EFI_IFR_REF_OP
, (CHAR8
**)&mRef4
, sizeof(EFI_IFR_REF4
)),
1215 CIfrOpHeader (EFI_IFR_REF_OP
, &mRef4
->Header
, sizeof(EFI_IFR_REF4
)),
1216 CIfrQuestionHeader (&mRef4
->Question
) {
1218 mRef4
->QuestionId
= EFI_QUESTION_ID_INVALID
;
1219 memset (&mRef4
->FormSetId
, 0, sizeof (EFI_GUID
));
1220 mRef4
->DevicePath
= EFI_STRING_ID_INVALID
;
1223 VOID
SetFormId (IN EFI_FORM_ID FormId
) {
1224 mRef4
->FormId
= FormId
;
1227 VOID
SetQuestionId (IN EFI_QUESTION_ID QuestionId
) {
1228 mRef4
->QuestionId
= QuestionId
;
1231 VOID
SetFormSetId (IN EFI_GUID FormSetId
) {
1232 mRef4
->FormSetId
= FormSetId
;
1235 VOID
SetDevicePath (IN EFI_STRING_ID DevicePath
) {
1236 mRef4
->DevicePath
= DevicePath
;
1240 class CIfrRef5
: public CIfrObj
, public CIfrOpHeader
, public CIfrQuestionHeader
{
1242 EFI_IFR_REF5
*mRef5
;
1245 CIfrRef5 () : CIfrObj (EFI_IFR_REF_OP
, (CHAR8
**)&mRef5
, sizeof (EFI_IFR_REF5
)),
1246 CIfrOpHeader (EFI_IFR_REF_OP
, &mRef5
->Header
, sizeof (EFI_IFR_REF5
)),
1247 CIfrQuestionHeader (&mRef5
->Question
) {
1251 class CIfrResetButton
: public CIfrObj
, public CIfrOpHeader
, public CIfrStatementHeader
{
1253 EFI_IFR_RESET_BUTTON
*mResetButton
;
1256 CIfrResetButton () : CIfrObj (EFI_IFR_RESET_BUTTON_OP
, (CHAR8
**)&mResetButton
),
1257 CIfrOpHeader (EFI_IFR_RESET_BUTTON_OP
, &mResetButton
->Header
),
1258 CIfrStatementHeader (&mResetButton
->Statement
) {
1259 mResetButton
->DefaultId
= EFI_HII_DEFAULT_CLASS_STANDARD
;
1262 VOID
SetDefaultId (IN UINT16 DefaultId
) {
1263 mResetButton
->DefaultId
= DefaultId
;
1267 class CIfrCheckBox
: public CIfrObj
, public CIfrOpHeader
, public CIfrQuestionHeader
{
1269 EFI_IFR_CHECKBOX
*mCheckBox
;
1272 CIfrCheckBox () : CIfrObj (EFI_IFR_CHECKBOX_OP
, (CHAR8
**)&mCheckBox
),
1273 CIfrOpHeader (EFI_IFR_CHECKBOX_OP
, &mCheckBox
->Header
),
1274 CIfrQuestionHeader (&mCheckBox
->Question
) {
1275 mCheckBox
->Flags
= 0;
1276 gCurrentQuestion
= this;
1280 gCurrentQuestion
= NULL
;
1283 EFI_VFR_RETURN_CODE
SetFlags (IN UINT8 HFlags
, UINT8 LFlags
) {
1284 EFI_VFR_RETURN_CODE Ret
;
1286 Ret
= CIfrQuestionHeader::SetFlags (HFlags
);
1287 if (Ret
!= VFR_RETURN_SUCCESS
) {
1291 if (_FLAG_TEST_AND_CLEAR (LFlags
, EFI_IFR_CHECKBOX_DEFAULT
)) {
1292 mCheckBox
->Flags
|= EFI_IFR_CHECKBOX_DEFAULT
;
1295 if (_FLAG_TEST_AND_CLEAR (LFlags
, EFI_IFR_CHECKBOX_DEFAULT_MFG
)) {
1296 mCheckBox
->Flags
|= EFI_IFR_CHECKBOX_DEFAULT_MFG
;
1299 return _FLAGS_ZERO (LFlags
) ? VFR_RETURN_SUCCESS
: VFR_RETURN_FLAGS_UNSUPPORTED
;
1302 UINT8
GetFlags (VOID
) {
1303 return mCheckBox
->Flags
;
1307 class CIfrAction
: public CIfrObj
, public CIfrOpHeader
, public CIfrQuestionHeader
{
1309 EFI_IFR_ACTION
*mAction
;
1312 CIfrAction () : CIfrObj (EFI_IFR_ACTION_OP
, (CHAR8
**)&mAction
),
1313 CIfrOpHeader (EFI_IFR_ACTION_OP
, &mAction
->Header
),
1314 CIfrQuestionHeader (&mAction
->Question
) {
1315 mAction
->QuestionConfig
= EFI_STRING_ID_INVALID
;
1318 VOID
SetQuestionConfig (IN EFI_STRING_ID QuestionConfig
) {
1319 mAction
->QuestionConfig
= QuestionConfig
;
1323 class CIfrDate
: public CIfrObj
, public CIfrOpHeader
, public CIfrQuestionHeader
{
1325 EFI_IFR_DATE
*mDate
;
1328 CIfrDate () : CIfrObj (EFI_IFR_DATE_OP
, (CHAR8
**)&mDate
),
1329 CIfrOpHeader (EFI_IFR_DATE_OP
, &mDate
->Header
),
1330 CIfrQuestionHeader (&mDate
->Question
) {
1334 EFI_VFR_RETURN_CODE
SetFlags (IN UINT8 HFlags
, IN UINT8 LFlags
) {
1335 EFI_VFR_RETURN_CODE Ret
;
1337 Ret
= CIfrQuestionHeader::SetFlags (HFlags
);
1338 if (Ret
!= VFR_RETURN_SUCCESS
) {
1342 if (_FLAG_TEST_AND_CLEAR (LFlags
, EFI_QF_DATE_YEAR_SUPPRESS
)) {
1343 mDate
->Flags
|= EFI_QF_DATE_YEAR_SUPPRESS
;
1346 if (_FLAG_TEST_AND_CLEAR (LFlags
, EFI_QF_DATE_MONTH_SUPPRESS
)) {
1347 mDate
->Flags
|= EFI_QF_DATE_MONTH_SUPPRESS
;
1350 if (_FLAG_TEST_AND_CLEAR (LFlags
, EFI_QF_DATE_DAY_SUPPRESS
)) {
1351 mDate
->Flags
|= EFI_QF_DATE_DAY_SUPPRESS
;
1354 if (_FLAG_TEST_AND_CLEAR (LFlags
, QF_DATE_STORAGE_NORMAL
)) {
1355 mDate
->Flags
|= QF_DATE_STORAGE_NORMAL
;
1356 } else if (_FLAG_TEST_AND_CLEAR (LFlags
, QF_DATE_STORAGE_TIME
)) {
1357 mDate
->Flags
|= QF_DATE_STORAGE_TIME
;
1358 } else if (_FLAG_TEST_AND_CLEAR (LFlags
, QF_DATE_STORAGE_WAKEUP
)) {
1359 mDate
->Flags
|= QF_DATE_STORAGE_WAKEUP
;
1362 return _FLAGS_ZERO (LFlags
) ? VFR_RETURN_SUCCESS
: VFR_RETURN_FLAGS_UNSUPPORTED
;
1366 class CIfrNumeric
: public CIfrObj
, public CIfrOpHeader
, public CIfrQuestionHeader
, public CIfrMinMaxStepData
{
1368 EFI_IFR_NUMERIC
*mNumeric
;
1371 CIfrNumeric () : CIfrObj (EFI_IFR_NUMERIC_OP
, (CHAR8
**)&mNumeric
, sizeof (EFI_IFR_NUMERIC
), TRUE
),
1372 CIfrOpHeader (EFI_IFR_NUMERIC_OP
, &mNumeric
->Header
),
1373 CIfrQuestionHeader (&mNumeric
->Question
),
1374 CIfrMinMaxStepData (&mNumeric
->data
, TRUE
) {
1375 mNumeric
->Flags
= EFI_IFR_NUMERIC_SIZE_1
| EFI_IFR_DISPLAY_UINT_DEC
;
1376 gCurrentQuestion
= this;
1377 gCurrentMinMaxData
= this;
1381 gCurrentQuestion
= NULL
;
1382 gCurrentMinMaxData
= NULL
;
1385 VOID
ShrinkBinSize (IN UINT16 Size
) {
1387 // Update the buffer size which is truly be used later.
1393 // Allocate buffer in gCFormPkg.
1395 _EMIT_PENDING_OBJ();
1398 // Update the buffer pointer used by other class.
1400 mNumeric
= (EFI_IFR_NUMERIC
*) GetObjBinAddr();
1401 UpdateHeader (&mNumeric
->Header
);
1402 UpdateCIfrQuestionHeader(&mNumeric
->Question
);
1403 UpdateCIfrMinMaxStepData(&mNumeric
->data
);
1406 EFI_VFR_RETURN_CODE
SetFlags (IN UINT8 HFlags
, IN UINT8 LFlags
, BOOLEAN DisplaySettingsSpecified
= FALSE
) {
1407 EFI_VFR_RETURN_CODE Ret
;
1409 Ret
= CIfrQuestionHeader::SetFlags (HFlags
);
1410 if (Ret
!= VFR_RETURN_SUCCESS
) {
1414 if (DisplaySettingsSpecified
== FALSE
) {
1415 mNumeric
->Flags
= LFlags
| EFI_IFR_DISPLAY_UINT_DEC
;
1417 mNumeric
->Flags
= LFlags
;
1419 return VFR_RETURN_SUCCESS
;
1422 EFI_VFR_RETURN_CODE
SetFlagsForBitField (IN UINT8 HFlags
, IN UINT8 LFlags
, BOOLEAN DisplaySettingsSpecified
= FALSE
) {
1423 EFI_VFR_RETURN_CODE Ret
;
1425 Ret
= CIfrQuestionHeader::SetFlags (HFlags
);
1426 if (Ret
!= VFR_RETURN_SUCCESS
) {
1430 if (DisplaySettingsSpecified
== FALSE
) {
1431 mNumeric
->Flags
= LFlags
| EDKII_IFR_DISPLAY_UINT_DEC_BIT
;
1433 mNumeric
->Flags
= LFlags
;
1435 return VFR_RETURN_SUCCESS
;
1438 UINT8
GetNumericFlags () {
1439 return mNumeric
->Flags
;
1443 class CIfrOneOf
: public CIfrObj
, public CIfrOpHeader
, public CIfrQuestionHeader
, public CIfrMinMaxStepData
{
1445 EFI_IFR_ONE_OF
*mOneOf
;
1448 CIfrOneOf () : CIfrObj (EFI_IFR_ONE_OF_OP
, (CHAR8
**)&mOneOf
, sizeof (EFI_IFR_ONE_OF
), TRUE
),
1449 CIfrOpHeader (EFI_IFR_ONE_OF_OP
, &mOneOf
->Header
),
1450 CIfrQuestionHeader (&mOneOf
->Question
),
1451 CIfrMinMaxStepData (&mOneOf
->data
) {
1453 gCurrentQuestion
= this;
1454 gCurrentMinMaxData
= this;
1458 gCurrentQuestion
= NULL
;
1459 gCurrentMinMaxData
= NULL
;
1462 EFI_VFR_RETURN_CODE
SetFlags (IN UINT8 HFlags
, IN UINT8 LFlags
) {
1463 EFI_VFR_RETURN_CODE Ret
;
1465 Ret
= CIfrQuestionHeader::SetFlags (HFlags
);
1466 if (Ret
!= VFR_RETURN_SUCCESS
) {
1470 if (LFlags
& EFI_IFR_DISPLAY
) {
1471 mOneOf
->Flags
= LFlags
;
1473 mOneOf
->Flags
= LFlags
| EFI_IFR_DISPLAY_UINT_DEC
;
1475 return VFR_RETURN_SUCCESS
;
1478 EFI_VFR_RETURN_CODE
SetFlagsForBitField (IN UINT8 HFlags
, IN UINT8 LFlags
) {
1479 EFI_VFR_RETURN_CODE Ret
;
1481 Ret
= CIfrQuestionHeader::SetFlags (HFlags
);
1482 if (Ret
!= VFR_RETURN_SUCCESS
) {
1486 if (LFlags
& EFI_IFR_DISPLAY
) {
1487 mOneOf
->Flags
= LFlags
;
1489 mOneOf
->Flags
= LFlags
| EDKII_IFR_DISPLAY_UINT_DEC_BIT
;
1491 return VFR_RETURN_SUCCESS
;
1494 VOID
ShrinkBinSize (IN UINT16 Size
) {
1496 // Update the buffer size which is truly be used later.
1502 // Allocate buffer in gCFormPkg.
1504 _EMIT_PENDING_OBJ();
1507 // Update the buffer pointer used by other class.
1509 mOneOf
= (EFI_IFR_ONE_OF
*) GetObjBinAddr();
1510 UpdateHeader (&mOneOf
->Header
);
1511 UpdateCIfrQuestionHeader(&mOneOf
->Question
);
1512 UpdateCIfrMinMaxStepData(&mOneOf
->data
);
1516 class CIfrString
: public CIfrObj
, public CIfrOpHeader
, public CIfrQuestionHeader
{
1518 EFI_IFR_STRING
*mString
;
1521 CIfrString () : CIfrObj (EFI_IFR_STRING_OP
, (CHAR8
**)&mString
),
1522 CIfrOpHeader (EFI_IFR_STRING_OP
, &mString
->Header
),
1523 CIfrQuestionHeader (&mString
->Question
) {
1525 mString
->MinSize
= 0;
1526 mString
->MaxSize
= 0;
1527 gCurrentQuestion
= this;
1531 gCurrentQuestion
= NULL
;
1534 EFI_VFR_RETURN_CODE
SetFlags (IN UINT8 HFlags
, IN UINT8 LFlags
) {
1535 EFI_VFR_RETURN_CODE Ret
;
1537 Ret
= CIfrQuestionHeader::SetFlags (HFlags
);
1538 if (Ret
!= VFR_RETURN_SUCCESS
) {
1542 if (_FLAG_TEST_AND_CLEAR (LFlags
, EFI_IFR_STRING_MULTI_LINE
)) {
1543 mString
->Flags
|= EFI_IFR_STRING_MULTI_LINE
;
1546 return _FLAGS_ZERO (LFlags
) ? VFR_RETURN_SUCCESS
: VFR_RETURN_FLAGS_UNSUPPORTED
;
1549 VOID
SetMinSize (IN UINT8 Flags
) {
1550 mString
->MinSize
= Flags
;
1553 VOID
SetMaxSize (IN UINT8 MaxSize
) {
1554 mString
->MaxSize
= MaxSize
;
1558 class CIfrPassword
: public CIfrObj
, public CIfrOpHeader
, public CIfrQuestionHeader
{
1560 EFI_IFR_PASSWORD
*mPassword
;
1563 CIfrPassword () : CIfrObj (EFI_IFR_PASSWORD_OP
, (CHAR8
**)&mPassword
),
1564 CIfrOpHeader (EFI_IFR_PASSWORD_OP
, &mPassword
->Header
),
1565 CIfrQuestionHeader (&mPassword
->Question
) {
1566 mPassword
->MinSize
= 0;
1567 mPassword
->MaxSize
= 0;
1568 gCurrentQuestion
= this;
1572 gCurrentQuestion
= NULL
;
1575 VOID
SetMinSize (IN UINT16 MinSize
) {
1576 mPassword
->MinSize
= MinSize
;
1579 VOID
SetMaxSize (IN UINT16 MaxSize
) {
1580 mPassword
->MaxSize
= MaxSize
;
1584 class CIfrOrderedList
: public CIfrObj
, public CIfrOpHeader
, public CIfrQuestionHeader
{
1586 EFI_IFR_ORDERED_LIST
*mOrderedList
;
1589 CIfrOrderedList () : CIfrObj (EFI_IFR_ORDERED_LIST_OP
, (CHAR8
**)&mOrderedList
),
1590 CIfrOpHeader (EFI_IFR_ORDERED_LIST_OP
, &mOrderedList
->Header
),
1591 CIfrQuestionHeader (&mOrderedList
->Question
) {
1592 mOrderedList
->MaxContainers
= 0;
1593 mOrderedList
->Flags
= 0;
1594 gCurrentQuestion
= this;
1597 ~CIfrOrderedList () {
1598 gCurrentQuestion
= NULL
;
1601 VOID
SetMaxContainers (IN UINT8 MaxContainers
) {
1602 mOrderedList
->MaxContainers
= MaxContainers
;
1605 EFI_VFR_RETURN_CODE
SetFlags (IN UINT8 HFlags
, IN UINT8 LFlags
) {
1606 EFI_VFR_RETURN_CODE Ret
;
1608 Ret
= CIfrQuestionHeader::SetFlags (HFlags
);
1609 if (Ret
!= VFR_RETURN_SUCCESS
) {
1613 if (_FLAG_TEST_AND_CLEAR (LFlags
, EFI_IFR_UNIQUE_SET
)) {
1614 mOrderedList
->Flags
|= EFI_IFR_UNIQUE_SET
;
1617 if (_FLAG_TEST_AND_CLEAR (LFlags
, EFI_IFR_NO_EMPTY_SET
)) {
1618 mOrderedList
->Flags
|= EFI_IFR_NO_EMPTY_SET
;
1621 return _FLAGS_ZERO (LFlags
) ? VFR_RETURN_SUCCESS
: VFR_RETURN_FLAGS_UNSUPPORTED
;
1625 class CIfrTime
: public CIfrObj
, public CIfrOpHeader
, public CIfrQuestionHeader
{
1627 EFI_IFR_TIME
*mTime
;
1630 CIfrTime () : CIfrObj (EFI_IFR_TIME_OP
, (CHAR8
**)&mTime
),
1631 CIfrOpHeader (EFI_IFR_TIME_OP
, &mTime
->Header
),
1632 CIfrQuestionHeader (&mTime
->Question
) {
1636 EFI_VFR_RETURN_CODE
SetFlags (IN UINT8 HFlags
, IN UINT8 LFlags
) {
1637 EFI_VFR_RETURN_CODE Ret
;
1639 Ret
= CIfrQuestionHeader::SetFlags (HFlags
);
1640 if (Ret
!= VFR_RETURN_SUCCESS
) {
1644 if (_FLAG_TEST_AND_CLEAR (LFlags
, QF_TIME_HOUR_SUPPRESS
)) {
1645 mTime
->Flags
|= QF_TIME_HOUR_SUPPRESS
;
1648 if (_FLAG_TEST_AND_CLEAR (LFlags
, QF_TIME_MINUTE_SUPPRESS
)) {
1649 mTime
->Flags
|= QF_TIME_MINUTE_SUPPRESS
;
1652 if (_FLAG_TEST_AND_CLEAR (LFlags
, QF_TIME_SECOND_SUPPRESS
)) {
1653 mTime
->Flags
|= QF_TIME_SECOND_SUPPRESS
;
1656 if (_FLAG_TEST_AND_CLEAR (LFlags
, QF_TIME_STORAGE_NORMAL
)) {
1657 mTime
->Flags
|= QF_TIME_STORAGE_NORMAL
;
1658 } else if (_FLAG_TEST_AND_CLEAR (LFlags
, QF_TIME_STORAGE_TIME
)) {
1659 mTime
->Flags
|= QF_TIME_STORAGE_TIME
;
1660 } else if (_FLAG_TEST_AND_CLEAR (LFlags
, QF_TIME_STORAGE_WAKEUP
)) {
1661 mTime
->Flags
|= QF_TIME_STORAGE_WAKEUP
;
1664 return _FLAGS_ZERO (LFlags
) ? VFR_RETURN_SUCCESS
: VFR_RETURN_FLAGS_UNSUPPORTED
;
1668 class CIfrDisableIf
: public CIfrObj
, public CIfrOpHeader
{
1670 EFI_IFR_DISABLE_IF
*mDisableIf
;
1673 CIfrDisableIf () : CIfrObj (EFI_IFR_DISABLE_IF_OP
, (CHAR8
**)&mDisableIf
),
1674 mDisableIf ((EFI_IFR_DISABLE_IF
*) GetObjBinAddr()),
1675 CIfrOpHeader (EFI_IFR_DISABLE_IF_OP
, &mDisableIf
->Header
) {}
1678 class CIfrSuppressIf
: public CIfrObj
, public CIfrOpHeader
{
1680 EFI_IFR_SUPPRESS_IF
*mSuppressIf
;
1683 CIfrSuppressIf () : CIfrObj (EFI_IFR_SUPPRESS_IF_OP
, (CHAR8
**)&mSuppressIf
),
1684 CIfrOpHeader (EFI_IFR_SUPPRESS_IF_OP
, &mSuppressIf
->Header
) {}
1687 class CIfrGrayOutIf
: public CIfrObj
, public CIfrOpHeader
{
1689 EFI_IFR_GRAY_OUT_IF
*mGrayOutIf
;
1692 CIfrGrayOutIf () : CIfrObj (EFI_IFR_GRAY_OUT_IF_OP
, (CHAR8
**)&mGrayOutIf
),
1693 CIfrOpHeader (EFI_IFR_GRAY_OUT_IF_OP
, &mGrayOutIf
->Header
) {}
1696 class CIfrInconsistentIf
: public CIfrObj
, public CIfrOpHeader
{
1698 EFI_IFR_INCONSISTENT_IF
*mInconsistentIf
;
1701 CIfrInconsistentIf () : CIfrObj (EFI_IFR_INCONSISTENT_IF_OP
, (CHAR8
**)&mInconsistentIf
),
1702 CIfrOpHeader (EFI_IFR_INCONSISTENT_IF_OP
, &mInconsistentIf
->Header
) {
1703 mInconsistentIf
->Error
= EFI_STRING_ID_INVALID
;
1706 VOID
SetError (IN EFI_STRING_ID Error
) {
1707 mInconsistentIf
->Error
= Error
;
1711 class CIfrWarningIf
: public CIfrObj
, public CIfrOpHeader
{
1713 EFI_IFR_WARNING_IF
*mWarningIf
;
1716 CIfrWarningIf () : CIfrObj (EFI_IFR_WARNING_IF_OP
, (CHAR8
**)&mWarningIf
),
1717 CIfrOpHeader (EFI_IFR_WARNING_IF_OP
, &mWarningIf
->Header
) {
1718 mWarningIf
->Warning
= EFI_STRING_ID_INVALID
;
1719 mWarningIf
->TimeOut
= 0;
1722 VOID
SetWarning (IN EFI_STRING_ID Warning
) {
1723 mWarningIf
->Warning
= Warning
;
1726 VOID
SetTimeOut (IN UINT8 TimeOut
) {
1727 mWarningIf
->TimeOut
= TimeOut
;
1731 class CIfrNoSubmitIf
: public CIfrObj
, public CIfrOpHeader
{
1733 EFI_IFR_NO_SUBMIT_IF
*mNoSubmitIf
;
1736 CIfrNoSubmitIf () : CIfrObj (EFI_IFR_NO_SUBMIT_IF_OP
, (CHAR8
**)&mNoSubmitIf
),
1737 CIfrOpHeader (EFI_IFR_NO_SUBMIT_IF_OP
, &mNoSubmitIf
->Header
) {
1738 mNoSubmitIf
->Error
= EFI_STRING_ID_INVALID
;
1741 VOID
SetError (IN EFI_STRING_ID Error
) {
1742 mNoSubmitIf
->Error
= Error
;
1746 class CIfrRefresh
: public CIfrObj
, public CIfrOpHeader
{
1748 EFI_IFR_REFRESH
*mRefresh
;
1751 CIfrRefresh () : CIfrObj (EFI_IFR_REFRESH_OP
, (CHAR8
**)&mRefresh
),
1752 CIfrOpHeader (EFI_IFR_REFRESH_OP
, &mRefresh
->Header
) {
1753 mRefresh
->RefreshInterval
= 0;
1756 VOID
SetRefreshInterval (IN UINT8 RefreshInterval
) {
1757 mRefresh
->RefreshInterval
= RefreshInterval
;
1761 class CIfrRefreshId
: public CIfrObj
, public CIfrOpHeader
{
1763 EFI_IFR_REFRESH_ID
*mRefreshId
;
1766 CIfrRefreshId () : CIfrObj (EFI_IFR_REFRESH_ID_OP
, (CHAR8
**)&mRefreshId
),
1767 CIfrOpHeader (EFI_IFR_REFRESH_ID_OP
, &mRefreshId
->Header
) {
1768 memset (&mRefreshId
->RefreshEventGroupId
, 0, sizeof (EFI_GUID
));
1771 VOID
SetRefreshEventGroutId (IN EFI_GUID
*RefreshEventGroupId
) {
1772 memmove (&mRefreshId
->RefreshEventGroupId
, RefreshEventGroupId
, sizeof (EFI_GUID
));
1776 class CIfrVarStoreDevice
: public CIfrObj
, public CIfrOpHeader
{
1778 EFI_IFR_VARSTORE_DEVICE
*mVarStoreDevice
;
1781 CIfrVarStoreDevice () : CIfrObj (EFI_IFR_VARSTORE_DEVICE_OP
, (CHAR8
**)&mVarStoreDevice
),
1782 CIfrOpHeader (EFI_IFR_VARSTORE_DEVICE_OP
, &mVarStoreDevice
->Header
) {
1783 mVarStoreDevice
->DevicePath
= EFI_STRING_ID_INVALID
;
1786 VOID
SetDevicePath (IN EFI_STRING_ID DevicePath
) {
1787 mVarStoreDevice
->DevicePath
= DevicePath
;
1791 class CIfrOneOfOption
: public CIfrObj
, public CIfrOpHeader
{
1793 EFI_IFR_ONE_OF_OPTION
*mOneOfOption
;
1796 CIfrOneOfOption (UINT8 Size
) : CIfrObj (EFI_IFR_ONE_OF_OPTION_OP
, (CHAR8
**)&mOneOfOption
, Size
),
1797 CIfrOpHeader (EFI_IFR_ONE_OF_OPTION_OP
, &mOneOfOption
->Header
, Size
) {
1798 mOneOfOption
->Flags
= 0;
1799 mOneOfOption
->Option
= EFI_STRING_ID_INVALID
;
1800 mOneOfOption
->Type
= EFI_IFR_TYPE_OTHER
;
1801 memset (&mOneOfOption
->Value
, 0, Size
- OFFSET_OF (EFI_IFR_ONE_OF_OPTION
, Value
));
1804 VOID
SetOption (IN EFI_STRING_ID Option
) {
1805 mOneOfOption
->Option
= Option
;
1808 EFI_VFR_RETURN_CODE
SetFlags (IN UINT8 LFlags
) {
1809 mOneOfOption
->Flags
= 0;
1810 if (_FLAG_TEST_AND_CLEAR (LFlags
, EFI_IFR_OPTION_DEFAULT
)) {
1811 mOneOfOption
->Flags
|= EFI_IFR_OPTION_DEFAULT
;
1814 if (_FLAG_TEST_AND_CLEAR (LFlags
, EFI_IFR_OPTION_DEFAULT_MFG
)) {
1815 mOneOfOption
->Flags
|= EFI_IFR_OPTION_DEFAULT_MFG
;
1818 if (_IS_EQUAL (LFlags
, EFI_IFR_TYPE_NUM_SIZE_8
)) {
1819 _FLAG_CLEAR (LFlags
, EFI_IFR_TYPE_NUM_SIZE_8
);
1820 mOneOfOption
->Flags
|= EFI_IFR_TYPE_NUM_SIZE_8
;
1821 } else if (_IS_EQUAL (LFlags
, EFI_IFR_TYPE_NUM_SIZE_16
)) {
1822 _FLAG_CLEAR (LFlags
, EFI_IFR_TYPE_NUM_SIZE_16
);
1823 mOneOfOption
->Flags
|= EFI_IFR_TYPE_NUM_SIZE_16
;
1824 } else if (_IS_EQUAL (LFlags
, EFI_IFR_TYPE_NUM_SIZE_32
)) {
1825 _FLAG_CLEAR (LFlags
, EFI_IFR_TYPE_NUM_SIZE_32
);
1826 mOneOfOption
->Flags
|= EFI_IFR_TYPE_NUM_SIZE_32
;
1827 } else if (_IS_EQUAL (LFlags
, EFI_IFR_TYPE_NUM_SIZE_64
)) {
1828 _FLAG_CLEAR (LFlags
, EFI_IFR_TYPE_NUM_SIZE_64
);
1829 mOneOfOption
->Flags
|= EFI_IFR_TYPE_NUM_SIZE_64
;
1830 } else if (_IS_EQUAL (LFlags
, EFI_IFR_TYPE_BOOLEAN
)) {
1831 _FLAG_CLEAR (LFlags
, EFI_IFR_TYPE_BOOLEAN
);
1832 mOneOfOption
->Flags
|= EFI_IFR_TYPE_BOOLEAN
;
1833 } else if (_IS_EQUAL (LFlags
, EFI_IFR_TYPE_TIME
)) {
1834 _FLAG_CLEAR (LFlags
, EFI_IFR_TYPE_TIME
);
1835 mOneOfOption
->Flags
|= EFI_IFR_TYPE_TIME
;
1836 } else if (_IS_EQUAL (LFlags
, EFI_IFR_TYPE_DATE
)) {
1837 _FLAG_CLEAR (LFlags
, EFI_IFR_TYPE_DATE
);
1838 mOneOfOption
->Flags
|= EFI_IFR_TYPE_DATE
;
1839 } else if (_IS_EQUAL (LFlags
, EFI_IFR_TYPE_STRING
)) {
1840 _FLAG_CLEAR (LFlags
, EFI_IFR_TYPE_STRING
);
1841 mOneOfOption
->Flags
|= EFI_IFR_TYPE_STRING
;
1842 } else if (_IS_EQUAL (LFlags
, EFI_IFR_TYPE_OTHER
)) {
1843 _FLAG_CLEAR (LFlags
, EFI_IFR_TYPE_OTHER
);
1844 mOneOfOption
->Flags
|= EFI_IFR_TYPE_OTHER
;
1847 return _FLAGS_ZERO (LFlags
) ? VFR_RETURN_SUCCESS
: VFR_RETURN_FLAGS_UNSUPPORTED
;
1850 VOID
SetType (IN UINT8 Type
) {
1851 mOneOfOption
->Type
= Type
;
1854 VOID
SetValue (IN EFI_IFR_TYPE_VALUE Value
) {
1855 memmove (&mOneOfOption
->Value
, &Value
, mOneOfOption
->Header
.Length
- OFFSET_OF (EFI_IFR_ONE_OF_OPTION
, Value
));
1858 UINT8
GetFlags (VOID
) {
1859 return mOneOfOption
->Flags
;
1863 static EFI_GUID IfrTianoGuid
= EFI_IFR_TIANO_GUID
;
1864 static EFI_GUID IfrFrameworkGuid
= EFI_IFR_FRAMEWORK_GUID
;
1866 class CIfrClass
: public CIfrObj
, public CIfrOpHeader
{
1868 EFI_IFR_GUID_CLASS
*mClass
;
1871 CIfrClass () : CIfrObj (EFI_IFR_GUID_OP
, (CHAR8
**)&mClass
, sizeof (EFI_IFR_GUID_CLASS
)),
1872 CIfrOpHeader (EFI_IFR_GUID_OP
, &mClass
->Header
, sizeof (EFI_IFR_GUID_CLASS
)) {
1873 mClass
->ExtendOpCode
= EFI_IFR_EXTEND_OP_CLASS
;
1874 mClass
->Guid
= IfrTianoGuid
;
1875 mClass
->Class
= EFI_NON_DEVICE_CLASS
;
1878 VOID
SetClass (IN UINT16 Class
) {
1879 mClass
->Class
= Class
;
1883 class CIfrSubClass
: public CIfrObj
, public CIfrOpHeader
{
1885 EFI_IFR_GUID_SUBCLASS
*mSubClass
;
1888 CIfrSubClass () : CIfrObj (EFI_IFR_GUID_OP
, (CHAR8
**)&mSubClass
, sizeof (EFI_IFR_GUID_SUBCLASS
)),
1889 CIfrOpHeader (EFI_IFR_GUID_OP
, &mSubClass
->Header
, sizeof (EFI_IFR_GUID_SUBCLASS
)) {
1890 mSubClass
->ExtendOpCode
= EFI_IFR_EXTEND_OP_SUBCLASS
;
1891 mSubClass
->Guid
= IfrTianoGuid
;
1892 mSubClass
->SubClass
= EFI_SETUP_APPLICATION_SUBCLASS
;
1895 VOID
SetSubClass (IN UINT16 SubClass
) {
1896 mSubClass
->SubClass
= SubClass
;
1900 class CIfrLabel
: public CIfrObj
, public CIfrOpHeader
{
1902 EFI_IFR_GUID_LABEL
*mLabel
;
1905 CIfrLabel () : CIfrObj (EFI_IFR_GUID_OP
, (CHAR8
**)&mLabel
, sizeof (EFI_IFR_GUID_LABEL
)),
1906 CIfrOpHeader (EFI_IFR_GUID_OP
, &mLabel
->Header
, sizeof (EFI_IFR_GUID_LABEL
)) {
1907 mLabel
->ExtendOpCode
= EFI_IFR_EXTEND_OP_LABEL
;
1908 mLabel
->Guid
= IfrTianoGuid
;
1911 VOID
SetNumber (IN UINT16 Number
) {
1912 mLabel
->Number
= Number
;
1916 class CIfrBanner
: public CIfrObj
, public CIfrOpHeader
{
1918 EFI_IFR_GUID_BANNER
*mBanner
;
1921 CIfrBanner () : CIfrObj (EFI_IFR_GUID_OP
, (CHAR8
**)&mBanner
, sizeof (EFI_IFR_GUID_BANNER
)),
1922 CIfrOpHeader (EFI_IFR_GUID_OP
, &mBanner
->Header
, sizeof (EFI_IFR_GUID_BANNER
)) {
1923 mBanner
->ExtendOpCode
= EFI_IFR_EXTEND_OP_BANNER
;
1924 mBanner
->Guid
= IfrTianoGuid
;
1927 VOID
SetTitle (IN EFI_STRING_ID StringId
) {
1928 mBanner
->Title
= StringId
;
1931 VOID
SetLine (IN UINT16 Line
) {
1932 mBanner
->LineNumber
= Line
;
1935 VOID
SetAlign (IN UINT8 Align
) {
1936 mBanner
->Alignment
= Align
;
1940 class CIfrOptionKey
: public CIfrObj
, public CIfrOpHeader
{
1942 EFI_IFR_GUID_OPTIONKEY
*mOptionKey
;
1946 IN EFI_QUESTION_ID QuestionId
,
1947 IN EFI_IFR_TYPE_VALUE
&OptionValue
,
1948 IN EFI_QUESTION_ID KeyValue
1949 ) : CIfrObj (EFI_IFR_GUID_OP
, (CHAR8
**)&mOptionKey
, sizeof (EFI_IFR_GUID_OPTIONKEY
)),
1950 CIfrOpHeader (EFI_IFR_GUID_OP
, &mOptionKey
->Header
, sizeof (EFI_IFR_GUID_OPTIONKEY
)) {
1951 mOptionKey
->ExtendOpCode
= EFI_IFR_EXTEND_OP_OPTIONKEY
;
1952 mOptionKey
->Guid
= IfrFrameworkGuid
;
1953 mOptionKey
->QuestionId
= QuestionId
;
1954 mOptionKey
->OptionValue
= OptionValue
;
1955 mOptionKey
->KeyValue
= KeyValue
;
1959 class CIfrVarEqName
: public CIfrObj
, public CIfrOpHeader
{
1961 EFI_IFR_GUID_VAREQNAME
*mVarEqName
;
1965 IN EFI_QUESTION_ID QuestionId
,
1966 IN EFI_STRING_ID NameId
1967 ) : CIfrObj (EFI_IFR_GUID_OP
, (CHAR8
**)&mVarEqName
, sizeof (EFI_IFR_GUID_VAREQNAME
)),
1968 CIfrOpHeader (EFI_IFR_GUID_OP
, &mVarEqName
->Header
, sizeof (EFI_IFR_GUID_VAREQNAME
)) {
1969 mVarEqName
->ExtendOpCode
= EFI_IFR_EXTEND_OP_VAREQNAME
;
1970 mVarEqName
->Guid
= IfrFrameworkGuid
;
1971 mVarEqName
->QuestionId
= QuestionId
;
1972 mVarEqName
->NameId
= NameId
;
1976 class CIfrTimeout
: public CIfrObj
, public CIfrOpHeader
{
1978 EFI_IFR_GUID_TIMEOUT
*mTimeout
;
1981 CIfrTimeout (IN UINT16 Timeout
= 0) : CIfrObj (EFI_IFR_GUID_OP
, (CHAR8
**)&mTimeout
, sizeof (EFI_IFR_GUID_TIMEOUT
)),
1982 CIfrOpHeader (EFI_IFR_GUID_OP
, &mTimeout
->Header
, sizeof (EFI_IFR_GUID_TIMEOUT
)) {
1983 mTimeout
->ExtendOpCode
= EFI_IFR_EXTEND_OP_TIMEOUT
;
1984 mTimeout
->Guid
= IfrTianoGuid
;
1985 mTimeout
->TimeOut
= Timeout
;
1988 VOID
SetTimeout (IN UINT16 Timeout
) {
1989 mTimeout
->TimeOut
= Timeout
;
1993 class CIfrGuid
: public CIfrObj
, public CIfrOpHeader
{
1995 EFI_IFR_GUID
*mGuid
;
1998 CIfrGuid (UINT8 Size
) : CIfrObj (EFI_IFR_GUID_OP
, (CHAR8
**)&mGuid
, sizeof (EFI_IFR_GUID
)+Size
),
1999 CIfrOpHeader (EFI_IFR_GUID_OP
, &mGuid
->Header
, sizeof (EFI_IFR_GUID
)+Size
) {
2000 memset (&mGuid
->Guid
, 0, sizeof (EFI_GUID
));
2003 VOID
SetGuid (IN EFI_GUID
*Guid
) {
2004 memmove (&mGuid
->Guid
, Guid
, sizeof (EFI_GUID
));
2007 VOID
SetData (IN UINT8
* DataBuff
, IN UINT8 Size
) {
2008 memmove ((UINT8
*)mGuid
+ sizeof (EFI_IFR_GUID
), DataBuff
, Size
);
2012 class CIfrDup
: public CIfrObj
, public CIfrOpHeader
{
2019 ) : CIfrObj (EFI_IFR_DUP_OP
, (CHAR8
**)&mDup
),
2020 CIfrOpHeader (EFI_IFR_DUP_OP
, &mDup
->Header
) {
2025 class CIfrEqIdId
: public CIfrObj
, public CIfrOpHeader
{
2027 EFI_IFR_EQ_ID_ID
*mEqIdId
;
2032 ) : CIfrObj (EFI_IFR_EQ_ID_ID_OP
, (CHAR8
**)&mEqIdId
),
2033 CIfrOpHeader (EFI_IFR_EQ_ID_ID_OP
, &mEqIdId
->Header
) {
2035 mEqIdId
->QuestionId1
= EFI_QUESTION_ID_INVALID
;
2036 mEqIdId
->QuestionId2
= EFI_QUESTION_ID_INVALID
;
2039 VOID
SetQuestionId1 (
2040 IN EFI_QUESTION_ID QuestionId
,
2044 if (QuestionId
!= EFI_QUESTION_ID_INVALID
) {
2045 mEqIdId
->QuestionId1
= QuestionId
;
2047 gCFormPkg
.AssignPending (VarIdStr
, (VOID
*)(&mEqIdId
->QuestionId1
), sizeof (EFI_QUESTION_ID
), LineNo
, NO_QST_REFED
);
2051 VOID
SetQuestionId2 (
2052 IN EFI_QUESTION_ID QuestionId
,
2056 if (QuestionId
!= EFI_QUESTION_ID_INVALID
) {
2057 mEqIdId
->QuestionId2
= QuestionId
;
2059 gCFormPkg
.AssignPending (VarIdStr
, (VOID
*)(&mEqIdId
->QuestionId2
), sizeof (EFI_QUESTION_ID
), LineNo
, NO_QST_REFED
);
2064 class CIfrEqIdVal
: public CIfrObj
, public CIfrOpHeader
{
2066 EFI_IFR_EQ_ID_VAL
*mEqIdVal
;
2071 ) : CIfrObj (EFI_IFR_EQ_ID_VAL_OP
, (CHAR8
**)&mEqIdVal
),
2072 CIfrOpHeader (EFI_IFR_EQ_ID_VAL_OP
, &mEqIdVal
->Header
) {
2074 mEqIdVal
->QuestionId
= EFI_QUESTION_ID_INVALID
;
2077 VOID
SetQuestionId (
2078 IN EFI_QUESTION_ID QuestionId
,
2082 if (QuestionId
!= EFI_QUESTION_ID_INVALID
) {
2083 mEqIdVal
->QuestionId
= QuestionId
;
2085 gCFormPkg
.AssignPending (VarIdStr
, (VOID
*)(&mEqIdVal
->QuestionId
), sizeof (EFI_QUESTION_ID
), LineNo
, NO_QST_REFED
);
2089 VOID
SetValue (IN UINT16 Value
) {
2090 mEqIdVal
->Value
= Value
;
2094 class CIfrEqIdList
: public CIfrObj
, public CIfrOpHeader
{
2096 EFI_IFR_EQ_ID_VAL_LIST
*mEqIdVList
;
2101 ) : CIfrObj (EFI_IFR_EQ_ID_VAL_LIST_OP
, (CHAR8
**)&mEqIdVList
, sizeof (EFI_IFR_EQ_ID_VAL_LIST
), TRUE
),
2102 CIfrOpHeader (EFI_IFR_EQ_ID_VAL_LIST_OP
, &mEqIdVList
->Header
) {
2104 mEqIdVList
->QuestionId
= EFI_QUESTION_ID_INVALID
;
2105 mEqIdVList
->ListLength
= 0;
2106 mEqIdVList
->ValueList
[0] = 0;
2109 VOID
UpdateIfrBuffer (
2111 _EMIT_PENDING_OBJ();
2112 mEqIdVList
= (EFI_IFR_EQ_ID_VAL_LIST
*) GetObjBinAddr();
2113 UpdateHeader (&mEqIdVList
->Header
);
2116 VOID
SetQuestionId (
2117 IN EFI_QUESTION_ID QuestionId
,
2121 if (QuestionId
!= EFI_QUESTION_ID_INVALID
) {
2122 mEqIdVList
->QuestionId
= QuestionId
;
2124 gCFormPkg
.AssignPending (VarIdStr
, (VOID
*)(&mEqIdVList
->QuestionId
), sizeof (EFI_QUESTION_ID
), LineNo
, NO_QST_REFED
);
2128 VOID
SetListLength (IN UINT16 ListLength
) {
2129 mEqIdVList
->ListLength
= ListLength
;
2132 VOID
SetValueList (IN UINT16 Index
, IN UINT16 Value
) {
2134 mEqIdVList
->ValueList
[0] = Value
;
2138 if (ExpendObjBin (sizeof (UINT16
)) ==TRUE
) {
2139 IncLength (sizeof (UINT16
));
2140 mEqIdVList
->ValueList
[Index
] = Value
;
2145 class CIfrQuestionRef1
: public CIfrObj
, public CIfrOpHeader
{
2147 EFI_IFR_QUESTION_REF1
*mQuestionRef1
;
2152 ) : CIfrObj (EFI_IFR_QUESTION_REF1_OP
, (CHAR8
**)&mQuestionRef1
),
2153 CIfrOpHeader (EFI_IFR_QUESTION_REF1_OP
, &mQuestionRef1
->Header
) {
2155 mQuestionRef1
->QuestionId
= EFI_QUESTION_ID_INVALID
;
2158 VOID
SetQuestionId (
2159 IN EFI_QUESTION_ID QuestionId
,
2163 if (QuestionId
!= EFI_QUESTION_ID_INVALID
) {
2164 mQuestionRef1
->QuestionId
= QuestionId
;
2166 gCFormPkg
.AssignPending (VarIdStr
, (VOID
*)(&mQuestionRef1
->QuestionId
), sizeof (EFI_QUESTION_ID
), LineNo
, NO_QST_REFED
);
2171 class CIfrQuestionRef2
: public CIfrObj
, public CIfrOpHeader
{
2173 EFI_IFR_QUESTION_REF2
*mQuestionRef2
;
2178 ) : CIfrObj (EFI_IFR_QUESTION_REF2_OP
, (CHAR8
**)&mQuestionRef2
),
2179 CIfrOpHeader (EFI_IFR_QUESTION_REF2_OP
, &mQuestionRef2
->Header
) {
2184 class CIfrQuestionRef3
: public CIfrObj
, public CIfrOpHeader
{
2186 EFI_IFR_QUESTION_REF3
*mQuestionRef3
;
2191 ) : CIfrObj (EFI_IFR_QUESTION_REF3_OP
, (CHAR8
**)&mQuestionRef3
),
2192 CIfrOpHeader (EFI_IFR_QUESTION_REF3_OP
, &mQuestionRef3
->Header
) {
2197 class CIfrQuestionRef3_2
: public CIfrObj
, public CIfrOpHeader
{
2199 EFI_IFR_QUESTION_REF3_2
*mQuestionRef3_2
;
2202 CIfrQuestionRef3_2 (
2204 ) : CIfrObj (EFI_IFR_QUESTION_REF3_OP
, (CHAR8
**)&mQuestionRef3_2
, sizeof (EFI_IFR_QUESTION_REF3_2
)),
2205 CIfrOpHeader (EFI_IFR_QUESTION_REF3_OP
, &mQuestionRef3_2
->Header
, sizeof (EFI_IFR_QUESTION_REF3_2
)) {
2207 mQuestionRef3_2
->DevicePath
= EFI_STRING_ID_INVALID
;
2210 VOID
SetDevicePath (IN EFI_STRING_ID DevicePath
) {
2211 mQuestionRef3_2
->DevicePath
= DevicePath
;
2215 class CIfrQuestionRef3_3
: public CIfrObj
, public CIfrOpHeader
{
2217 EFI_IFR_QUESTION_REF3_3
*mQuestionRef3_3
;
2220 CIfrQuestionRef3_3 (
2222 ) : CIfrObj (EFI_IFR_QUESTION_REF3_OP
, (CHAR8
**)&mQuestionRef3_3
, sizeof (EFI_IFR_QUESTION_REF3_3
)),
2223 CIfrOpHeader (EFI_IFR_QUESTION_REF3_OP
, &mQuestionRef3_3
->Header
, sizeof (EFI_IFR_QUESTION_REF3_3
)) {
2225 mQuestionRef3_3
->DevicePath
= EFI_STRING_ID_INVALID
;
2226 memset (&mQuestionRef3_3
->Guid
, 0, sizeof (EFI_GUID
));
2229 VOID
SetDevicePath (IN EFI_STRING_ID DevicePath
) {
2230 mQuestionRef3_3
->DevicePath
= DevicePath
;
2233 VOID
SetGuid (IN EFI_GUID
*Guid
) {
2234 mQuestionRef3_3
->Guid
= *Guid
;
2238 class CIfrRuleRef
: public CIfrObj
, public CIfrOpHeader
{
2240 EFI_IFR_RULE_REF
*mRuleRef
;
2245 ) : CIfrObj (EFI_IFR_RULE_REF_OP
, (CHAR8
**)&mRuleRef
),
2246 CIfrOpHeader (EFI_IFR_RULE_REF_OP
, &mRuleRef
->Header
) {
2248 mRuleRef
->RuleId
= EFI_RULE_ID_INVALID
;
2251 VOID
SetRuleId (IN UINT8 RuleId
) {
2252 mRuleRef
->RuleId
= RuleId
;
2256 class CIfrStringRef1
: public CIfrObj
, public CIfrOpHeader
{
2258 EFI_IFR_STRING_REF1
*mStringRef1
;
2263 ) : CIfrObj (EFI_IFR_STRING_REF1_OP
, (CHAR8
**)&mStringRef1
),
2264 CIfrOpHeader (EFI_IFR_STRING_REF1_OP
, &mStringRef1
->Header
) {
2266 mStringRef1
->StringId
= EFI_STRING_ID_INVALID
;
2269 VOID
SetStringId (IN EFI_STRING_ID StringId
) {
2270 mStringRef1
->StringId
= StringId
;
2274 class CIfrStringRef2
: public CIfrObj
, public CIfrOpHeader
{
2276 EFI_IFR_STRING_REF2
*mStringRef2
;
2281 ) : CIfrObj (EFI_IFR_STRING_REF2_OP
, (CHAR8
**)&mStringRef2
),
2282 CIfrOpHeader (EFI_IFR_STRING_REF2_OP
, &mStringRef2
->Header
) {
2287 class CIfrThis
: public CIfrObj
, public CIfrOpHeader
{
2289 EFI_IFR_THIS
*mThis
;
2294 ) : CIfrObj (EFI_IFR_THIS_OP
, (CHAR8
**)&mThis
),
2295 CIfrOpHeader (EFI_IFR_THIS_OP
, &mThis
->Header
) {
2300 class CIfrSecurity
: public CIfrObj
, public CIfrOpHeader
{
2302 EFI_IFR_SECURITY
*mSecurity
;
2307 ) : CIfrObj (EFI_IFR_SECURITY_OP
, (CHAR8
**)&mSecurity
),
2308 CIfrOpHeader (EFI_IFR_SECURITY_OP
, &mSecurity
->Header
) {
2310 memset (&mSecurity
->Permissions
, 0, sizeof (EFI_GUID
));
2313 VOID
SetPermissions (IN EFI_GUID
*Permissions
) {
2314 memmove (&mSecurity
->Permissions
, Permissions
, sizeof (EFI_GUID
));
2318 class CIfrUint8
: public CIfrObj
, public CIfrOpHeader
{
2320 EFI_IFR_UINT8
*mUint8
;
2325 ) : CIfrObj (EFI_IFR_UINT8_OP
, (CHAR8
**)&mUint8
),
2326 CIfrOpHeader (EFI_IFR_UINT8_OP
, &mUint8
->Header
) {
2330 VOID
SetValue (IN UINT8 Value
) {
2331 mUint8
->Value
= Value
;
2335 class CIfrUint16
: public CIfrObj
, public CIfrOpHeader
{
2337 EFI_IFR_UINT16
*mUint16
;
2342 ) : CIfrObj (EFI_IFR_UINT16_OP
, (CHAR8
**)&mUint16
),
2343 CIfrOpHeader (EFI_IFR_UINT16_OP
, &mUint16
->Header
) {
2347 VOID
SetValue (IN UINT16 Value
) {
2348 mUint16
->Value
= Value
;
2352 class CIfrUint32
: public CIfrObj
, public CIfrOpHeader
{
2354 EFI_IFR_UINT32
*mUint32
;
2359 ) : CIfrObj (EFI_IFR_UINT32_OP
, (CHAR8
**)&mUint32
),
2360 CIfrOpHeader (EFI_IFR_UINT32_OP
, &mUint32
->Header
) {
2364 VOID
SetValue (IN UINT32 Value
) {
2365 mUint32
->Value
= Value
;
2369 class CIfrUint64
: public CIfrObj
, public CIfrOpHeader
{
2371 EFI_IFR_UINT64
*mUint64
;
2376 ) : CIfrObj (EFI_IFR_UINT64_OP
, (CHAR8
**)&mUint64
),
2377 CIfrOpHeader (EFI_IFR_UINT64_OP
, &mUint64
->Header
) {
2381 VOID
SetValue (IN UINT64 Value
) {
2382 mUint64
->Value
= Value
;
2386 class CIfrTrue
: public CIfrObj
, public CIfrOpHeader
{
2388 EFI_IFR_TRUE
*mTrue
;
2393 ) : CIfrObj (EFI_IFR_TRUE_OP
, (CHAR8
**)&mTrue
),
2394 CIfrOpHeader (EFI_IFR_TRUE_OP
, &mTrue
->Header
) {
2399 class CIfrFalse
: public CIfrObj
, public CIfrOpHeader
{
2401 EFI_IFR_FALSE
*mFalse
;
2406 ) : CIfrObj (EFI_IFR_FALSE_OP
, (CHAR8
**)&mFalse
),
2407 CIfrOpHeader (EFI_IFR_FALSE_OP
, &mFalse
->Header
) {
2412 class CIfrOne
: public CIfrObj
, public CIfrOpHeader
{
2419 ) : CIfrObj (EFI_IFR_ONE_OP
, (CHAR8
**)&mOne
),
2420 CIfrOpHeader (EFI_IFR_ONE_OP
, &mOne
->Header
) {
2425 class CIfrOnes
: public CIfrObj
, public CIfrOpHeader
{
2427 EFI_IFR_ONES
*mOnes
;
2432 ) : CIfrObj (EFI_IFR_ONES_OP
, (CHAR8
**)&mOnes
),
2433 CIfrOpHeader (EFI_IFR_ONES_OP
, &mOnes
->Header
) {
2438 class CIfrZero
: public CIfrObj
, public CIfrOpHeader
{
2440 EFI_IFR_ZERO
*mZero
;
2445 ) : CIfrObj (EFI_IFR_ZERO_OP
, (CHAR8
**)&mZero
),
2446 CIfrOpHeader (EFI_IFR_ZERO_OP
, &mZero
->Header
) {
2451 class CIfrUndefined
: public CIfrObj
, public CIfrOpHeader
{
2453 EFI_IFR_UNDEFINED
*mUndefined
;
2458 ) : CIfrObj (EFI_IFR_UNDEFINED_OP
, (CHAR8
**)&mUndefined
),
2459 CIfrOpHeader (EFI_IFR_UNDEFINED_OP
, &mUndefined
->Header
) {
2464 class CIfrVersion
: public CIfrObj
, public CIfrOpHeader
{
2466 EFI_IFR_VERSION
*mVersion
;
2471 ) : CIfrObj (EFI_IFR_VERSION_OP
, (CHAR8
**)&mVersion
),
2472 CIfrOpHeader (EFI_IFR_VERSION_OP
, &mVersion
->Header
) {
2477 class CIfrLength
: public CIfrObj
, public CIfrOpHeader
{
2479 EFI_IFR_LENGTH
*mLength
;
2484 ) : CIfrObj (EFI_IFR_LENGTH_OP
, (CHAR8
**)&mLength
),
2485 CIfrOpHeader (EFI_IFR_LENGTH_OP
, &mLength
->Header
) {
2490 class CIfrNot
: public CIfrObj
, public CIfrOpHeader
{
2497 ) : CIfrObj (EFI_IFR_NOT_OP
, (CHAR8
**)&mNot
),
2498 CIfrOpHeader (EFI_IFR_NOT_OP
, &mNot
->Header
) {
2503 class CIfrBitWiseNot
: public CIfrObj
, public CIfrOpHeader
{
2505 EFI_IFR_BITWISE_NOT
*mBitWise
;
2510 ) : CIfrObj (EFI_IFR_BITWISE_NOT_OP
, (CHAR8
**)&mBitWise
),
2511 CIfrOpHeader (EFI_IFR_BITWISE_NOT_OP
, &mBitWise
->Header
) {
2516 class CIfrToBoolean
: public CIfrObj
, public CIfrOpHeader
{
2518 EFI_IFR_TO_BOOLEAN
*mToBoolean
;
2523 ) : CIfrObj (EFI_IFR_TO_BOOLEAN_OP
, (CHAR8
**)&mToBoolean
),
2524 CIfrOpHeader (EFI_IFR_TO_BOOLEAN_OP
, &mToBoolean
->Header
) {
2529 class CIfrToString
: public CIfrObj
, public CIfrOpHeader
{
2531 EFI_IFR_TO_STRING
*mToString
;
2536 ) : CIfrObj (EFI_IFR_TO_STRING_OP
, (CHAR8
**)&mToString
),
2537 CIfrOpHeader (EFI_IFR_TO_STRING_OP
, &mToString
->Header
) {
2541 VOID
SetFormat (IN UINT8 Format
) {
2542 mToString
->Format
= Format
;
2546 class CIfrToUint
: public CIfrObj
, public CIfrOpHeader
{
2548 EFI_IFR_TO_UINT
*mToUint
;
2553 ) : CIfrObj (EFI_IFR_TO_UINT_OP
, (CHAR8
**)&mToUint
),
2554 CIfrOpHeader (EFI_IFR_TO_UINT_OP
, &mToUint
->Header
) {
2559 class CIfrToUpper
: public CIfrObj
, public CIfrOpHeader
{
2561 EFI_IFR_TO_UPPER
*mToUpper
;
2566 ) : CIfrObj (EFI_IFR_TO_UPPER_OP
, (CHAR8
**)&mToUpper
),
2567 CIfrOpHeader (EFI_IFR_TO_UPPER_OP
, &mToUpper
->Header
) {
2572 class CIfrToLower
: public CIfrObj
, public CIfrOpHeader
{
2574 EFI_IFR_TO_LOWER
*mToLower
;
2579 ) : CIfrObj (EFI_IFR_TO_LOWER_OP
, (CHAR8
**)&mToLower
),
2580 CIfrOpHeader (EFI_IFR_TO_LOWER_OP
, &mToLower
->Header
) {
2585 class CIfrAdd
: public CIfrObj
, public CIfrOpHeader
{
2592 ) : CIfrObj (EFI_IFR_ADD_OP
, (CHAR8
**)&mAdd
),
2593 CIfrOpHeader (EFI_IFR_ADD_OP
, &mAdd
->Header
) {
2598 class CIfrBitWiseAnd
: public CIfrObj
, public CIfrOpHeader
{
2600 EFI_IFR_BITWISE_AND
*mBitWiseAnd
;
2605 ) : CIfrObj (EFI_IFR_BITWISE_AND_OP
, (CHAR8
**)&mBitWiseAnd
),
2606 CIfrOpHeader (EFI_IFR_BITWISE_AND_OP
, &mBitWiseAnd
->Header
) {
2611 class CIfrBitWiseOr
: public CIfrObj
, public CIfrOpHeader
{
2613 EFI_IFR_BITWISE_OR
*mBitWiseOr
;
2618 ) : CIfrObj (EFI_IFR_BITWISE_OR_OP
, (CHAR8
**)&mBitWiseOr
),
2619 CIfrOpHeader (EFI_IFR_BITWISE_OR_OP
, &mBitWiseOr
->Header
) {
2624 class CIfrAnd
: public CIfrObj
, public CIfrOpHeader
{
2631 ) : CIfrObj (EFI_IFR_AND_OP
, (CHAR8
**)&mAnd
),
2632 CIfrOpHeader (EFI_IFR_AND_OP
, &mAnd
->Header
) {
2637 class CIfrCatenate
: public CIfrObj
, public CIfrOpHeader
{
2639 EFI_IFR_CATENATE
*mCatenate
;
2644 ) : CIfrObj (EFI_IFR_CATENATE_OP
, (CHAR8
**)&mCatenate
),
2645 CIfrOpHeader (EFI_IFR_CATENATE_OP
, &mCatenate
->Header
) {
2650 class CIfrDivide
: public CIfrObj
, public CIfrOpHeader
{
2652 EFI_IFR_DIVIDE
*mDivide
;
2657 ) : CIfrObj (EFI_IFR_DIVIDE_OP
, (CHAR8
**)&mDivide
),
2658 CIfrOpHeader (EFI_IFR_DIVIDE_OP
, &mDivide
->Header
) {
2663 class CIfrEqual
: public CIfrObj
, public CIfrOpHeader
{
2665 EFI_IFR_EQUAL
*mEqual
;
2670 ) : CIfrObj (EFI_IFR_EQUAL_OP
, (CHAR8
**)&mEqual
),
2671 CIfrOpHeader (EFI_IFR_EQUAL_OP
, &mEqual
->Header
) {
2676 class CIfrGreaterEqual
: public CIfrObj
, public CIfrOpHeader
{
2678 EFI_IFR_GREATER_EQUAL
*mGreaterEqual
;
2683 ) : CIfrObj (EFI_IFR_GREATER_EQUAL_OP
, (CHAR8
**)&mGreaterEqual
),
2684 CIfrOpHeader (EFI_IFR_GREATER_EQUAL_OP
, &mGreaterEqual
->Header
) {
2689 class CIfrGreaterThan
: public CIfrObj
, public CIfrOpHeader
{
2691 EFI_IFR_GREATER_THAN
*mGreaterThan
;
2696 ) : CIfrObj (EFI_IFR_GREATER_THAN_OP
, (CHAR8
**)&mGreaterThan
),
2697 CIfrOpHeader (EFI_IFR_GREATER_THAN_OP
, &mGreaterThan
->Header
) {
2702 class CIfrLessEqual
: public CIfrObj
, public CIfrOpHeader
{
2704 EFI_IFR_LESS_EQUAL
*mLessEqual
;
2709 ) : CIfrObj (EFI_IFR_LESS_EQUAL_OP
, (CHAR8
**)&mLessEqual
),
2710 CIfrOpHeader (EFI_IFR_LESS_EQUAL_OP
, &mLessEqual
->Header
) {
2715 class CIfrLessThan
: public CIfrObj
, public CIfrOpHeader
{
2717 EFI_IFR_LESS_THAN
*mLessThan
;
2722 ) : CIfrObj (EFI_IFR_LESS_THAN_OP
, (CHAR8
**)&mLessThan
),
2723 CIfrOpHeader (EFI_IFR_LESS_THAN_OP
, &mLessThan
->Header
) {
2728 class CIfrMap
: public CIfrObj
, public CIfrOpHeader
{
2735 ) : CIfrObj (EFI_IFR_MAP_OP
, (CHAR8
**)&mMap
),
2736 CIfrOpHeader (EFI_IFR_MAP_OP
, &mMap
->Header
) {
2741 class CIfrMatch
: public CIfrObj
, public CIfrOpHeader
{
2743 EFI_IFR_MATCH
*mMatch
;
2748 ) : CIfrObj (EFI_IFR_MATCH_OP
, (CHAR8
**)&mMatch
),
2749 CIfrOpHeader (EFI_IFR_MATCH_OP
, &mMatch
->Header
) {
2754 class CIfrMatch2
: public CIfrObj
, public CIfrOpHeader
{
2756 EFI_IFR_MATCH2
*mMatch2
;
2762 ) : CIfrObj (EFI_IFR_MATCH2_OP
, (CHAR8
**)&mMatch2
),
2763 CIfrOpHeader (EFI_IFR_MATCH2_OP
, &mMatch2
->Header
) {
2765 memmove (&mMatch2
->SyntaxType
, Guid
, sizeof (EFI_GUID
));
2769 class CIfrMultiply
: public CIfrObj
, public CIfrOpHeader
{
2771 EFI_IFR_MULTIPLY
*mMultiply
;
2776 ) : CIfrObj (EFI_IFR_MULTIPLY_OP
, (CHAR8
**)&mMultiply
),
2777 CIfrOpHeader (EFI_IFR_MULTIPLY_OP
, &mMultiply
->Header
) {
2782 class CIfrModulo
: public CIfrObj
, public CIfrOpHeader
{
2784 EFI_IFR_MODULO
*mModulo
;
2789 ) : CIfrObj (EFI_IFR_MODULO_OP
, (CHAR8
**)&mModulo
),
2790 CIfrOpHeader (EFI_IFR_MODULO_OP
, &mModulo
->Header
) {
2795 class CIfrNotEqual
: public CIfrObj
, public CIfrOpHeader
{
2797 EFI_IFR_NOT_EQUAL
*mNotEqual
;
2802 ) : CIfrObj (EFI_IFR_NOT_EQUAL_OP
, (CHAR8
**)&mNotEqual
),
2803 CIfrOpHeader (EFI_IFR_NOT_EQUAL_OP
, &mNotEqual
->Header
) {
2808 class CIfrOr
: public CIfrObj
, public CIfrOpHeader
{
2815 ) : CIfrObj (EFI_IFR_OR_OP
, (CHAR8
**)&mOr
),
2816 CIfrOpHeader (EFI_IFR_OR_OP
, &mOr
->Header
) {
2821 class CIfrShiftLeft
: public CIfrObj
, public CIfrOpHeader
{
2823 EFI_IFR_SHIFT_LEFT
*mShiftLeft
;
2828 ) : CIfrObj (EFI_IFR_SHIFT_LEFT_OP
, (CHAR8
**)&mShiftLeft
),
2829 CIfrOpHeader (EFI_IFR_SHIFT_LEFT_OP
, &mShiftLeft
->Header
) {
2834 class CIfrShiftRight
: public CIfrObj
, public CIfrOpHeader
{
2836 EFI_IFR_SHIFT_RIGHT
*mShiftRight
;
2841 ) : CIfrObj (EFI_IFR_SHIFT_RIGHT_OP
, (CHAR8
**)&mShiftRight
),
2842 CIfrOpHeader (EFI_IFR_SHIFT_RIGHT_OP
, &mShiftRight
->Header
) {
2847 class CIfrSubtract
: public CIfrObj
, public CIfrOpHeader
{
2849 EFI_IFR_SUBTRACT
*mSubtract
;
2854 ) : CIfrObj (EFI_IFR_SUBTRACT_OP
, (CHAR8
**)&mSubtract
),
2855 CIfrOpHeader (EFI_IFR_SUBTRACT_OP
, &mSubtract
->Header
) {
2860 class CIfrConditional
: public CIfrObj
, public CIfrOpHeader
{
2862 EFI_IFR_CONDITIONAL
*mConditional
;
2867 ) : CIfrObj (EFI_IFR_CONDITIONAL_OP
, (CHAR8
**)&mConditional
),
2868 CIfrOpHeader (EFI_IFR_CONDITIONAL_OP
, &mConditional
->Header
) {
2873 class CIfrFind
: public CIfrObj
, public CIfrOpHeader
{
2875 EFI_IFR_FIND
*mFind
;
2880 ) : CIfrObj (EFI_IFR_FIND_OP
, (CHAR8
**)&mFind
),
2881 CIfrOpHeader (EFI_IFR_FIND_OP
, &mFind
->Header
) {
2885 VOID
SetFormat (IN UINT8 Format
) {
2886 mFind
->Format
= Format
;
2890 class CIfrMid
: public CIfrObj
, public CIfrOpHeader
{
2897 ) : CIfrObj (EFI_IFR_MID_OP
, (CHAR8
**)&mMid
),
2898 CIfrOpHeader (EFI_IFR_MID_OP
, &mMid
->Header
) {
2903 class CIfrToken
: public CIfrObj
, public CIfrOpHeader
{
2905 EFI_IFR_TOKEN
*mToken
;
2910 ) : CIfrObj (EFI_IFR_TOKEN_OP
, (CHAR8
**)&mToken
),
2911 CIfrOpHeader (EFI_IFR_TOKEN_OP
, &mToken
->Header
) {
2916 class CIfrSpan
: public CIfrObj
, public CIfrOpHeader
{
2918 EFI_IFR_SPAN
*mSpan
;
2923 ) : CIfrObj (EFI_IFR_SPAN_OP
, (CHAR8
**)&mSpan
),
2924 CIfrOpHeader (EFI_IFR_SPAN_OP
, &mSpan
->Header
) {
2926 mSpan
->Flags
= EFI_IFR_FLAGS_FIRST_MATCHING
;
2929 EFI_VFR_RETURN_CODE
SetFlags (IN UINT8 LFlags
) {
2930 if (_IS_EQUAL (LFlags
, EFI_IFR_FLAGS_FIRST_MATCHING
)) {
2931 mSpan
->Flags
|= EFI_IFR_FLAGS_FIRST_MATCHING
;
2932 } else if (_FLAG_TEST_AND_CLEAR (LFlags
, EFI_IFR_FLAGS_FIRST_NON_MATCHING
)) {
2933 mSpan
->Flags
|= EFI_IFR_FLAGS_FIRST_NON_MATCHING
;
2936 return _FLAGS_ZERO (LFlags
) ? VFR_RETURN_SUCCESS
: VFR_RETURN_FLAGS_UNSUPPORTED
;