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
) {
282 inline T
* GetObjBinAddr (VOID
) {
283 return reinterpret_cast<T
*>(mObjBinBuf
);
286 inline UINT32
GetObjBinOffset (VOID
) {
290 inline UINT8
GetObjBinLen (VOID
) {
294 inline bool ExpendObjBin (IN UINT8 Size
) {
295 if ((mDelayEmit
== TRUE
) && ((mObjBinLen
+ Size
) > mObjBinLen
)) {
296 mObjBinLen
= mObjBinLen
+ Size
;
303 inline bool ShrinkObjBin (IN UINT8 Size
) {
304 if ((mDelayEmit
== TRUE
) && (mObjBinLen
> Size
)) {
314 * The definition of CIfrOpHeader
318 EFI_IFR_OP_HEADER
*mHeader
;
321 CIfrOpHeader (IN UINT8 OpCode
, IN VOID
*StartAddr
, IN UINT8 Length
= 0);
322 CIfrOpHeader (IN CIfrOpHeader
&);
323 CIfrOpHeader
& operator=(IN CONST CIfrOpHeader
&);
325 VOID
IncLength (UINT8 Size
) {
326 if ((mHeader
->Length
+ Size
) > mHeader
->Length
) {
327 mHeader
->Length
= mHeader
->Length
+ Size
;
331 VOID
DecLength (UINT8 Size
) {
332 if (mHeader
->Length
>= Size
) {
333 mHeader
->Length
-= Size
;
338 return mHeader
->Length
;
342 return mHeader
->Scope
;
345 VOID
SetScope (IN UINT8 Scope
) {
346 mHeader
->Scope
= Scope
;
349 VOID
UpdateHeader (IN EFI_IFR_OP_HEADER
*Header
) {
354 return mHeader
->OpCode
;
358 extern UINT8 gScopeCount
;
361 * The definition of CIfrStatementHeader
363 class CIfrStatementHeader
{
365 EFI_IFR_STATEMENT_HEADER
*mHeader
;
368 CIfrStatementHeader (
369 IN EFI_IFR_STATEMENT_HEADER
*StartAddr
370 ) : mHeader ((EFI_IFR_STATEMENT_HEADER
*)StartAddr
) {
372 mHeader
->Help
= EFI_STRING_ID_INVALID
;
373 mHeader
->Prompt
= EFI_STRING_ID_INVALID
;
376 EFI_IFR_STATEMENT_HEADER
*GetStatementHeader () {
380 VOID
SetPrompt (IN EFI_STRING_ID Prompt
) {
381 mHeader
->Prompt
= Prompt
;
384 VOID
SetHelp (IN EFI_STRING_ID Help
) {
385 mHeader
->Help
= Help
;
390 * The definition of CIfrQuestionHeader
392 #define EFI_IFR_QUESTION_FLAG_DEFAULT 0
394 class CIfrQuestionHeader
: public CIfrStatementHeader
{
396 EFI_IFR_QUESTION_HEADER
*mHeader
;
398 EFI_IFR_STATEMENT_HEADER
* QH2SH (EFI_IFR_QUESTION_HEADER
*Qheader
) {
399 return &(Qheader
)->Header
;
403 EFI_QUESTION_ID
QUESTION_ID (VOID
) {
404 return mHeader
->QuestionId
;
407 EFI_VARSTORE_ID
VARSTORE_ID (VOID
) {
408 return mHeader
->VarStoreId
;
411 VOID
VARSTORE_INFO (OUT EFI_VARSTORE_INFO
*Info
) {
413 Info
->mVarStoreId
= mHeader
->VarStoreId
;
414 memmove (&Info
->mVarStoreId
, &mHeader
->VarStoreInfo
, sizeof (Info
->mVarStoreId
));
419 return mHeader
->Flags
;
424 IN EFI_IFR_QUESTION_HEADER
*StartAddr
,
425 IN UINT8 Flags
= EFI_IFR_QUESTION_FLAG_DEFAULT
426 ) : CIfrStatementHeader (QH2SH(StartAddr
)) {
428 mHeader
->QuestionId
= EFI_QUESTION_ID_INVALID
;
429 mHeader
->VarStoreId
= EFI_VARSTORE_ID_INVALID
;
430 mHeader
->VarStoreInfo
.VarName
= EFI_STRING_ID_INVALID
;
431 mHeader
->VarStoreInfo
.VarOffset
= EFI_VAROFFSET_INVALID
;
432 mHeader
->Flags
= Flags
;
435 VOID
SetQuestionId (IN EFI_QUESTION_ID QuestionId
) {
436 mHeader
->QuestionId
= QuestionId
;
439 VOID
SetVarStoreInfo (IN EFI_VARSTORE_INFO
*Info
) {
440 mHeader
->VarStoreId
= Info
->mVarStoreId
;
441 mHeader
->VarStoreInfo
.VarName
= Info
->mInfo
.mVarName
;
442 mHeader
->VarStoreInfo
.VarOffset
= Info
->mInfo
.mVarOffset
;
445 EFI_VFR_RETURN_CODE
SetFlags (IN UINT8 Flags
) {
446 if (_FLAG_TEST_AND_CLEAR (Flags
, EFI_IFR_FLAG_READ_ONLY
)) {
447 mHeader
->Flags
|= EFI_IFR_FLAG_READ_ONLY
;
450 _FLAG_CLEAR (Flags
, 0x02);
452 if (_FLAG_TEST_AND_CLEAR (Flags
, EFI_IFR_FLAG_CALLBACK
)) {
453 mHeader
->Flags
|= EFI_IFR_FLAG_CALLBACK
;
457 // ignore NVAccessFlag
459 _FLAG_CLEAR (Flags
, 0x08);
461 if (_FLAG_TEST_AND_CLEAR (Flags
, EFI_IFR_FLAG_RESET_REQUIRED
)) {
462 mHeader
->Flags
|= EFI_IFR_FLAG_RESET_REQUIRED
;
465 if (_FLAG_TEST_AND_CLEAR (Flags
, EFI_IFR_FLAG_RECONNECT_REQUIRED
)) {
466 mHeader
->Flags
|= EFI_IFR_FLAG_RECONNECT_REQUIRED
;
470 // Set LateCheck Flag to compatible for framework flag
471 // but it uses 0x20 as its flag, if in the future UEFI may take this flag
473 if (_FLAG_TEST_AND_CLEAR (Flags
, 0x20)) {
474 mHeader
->Flags
|= 0x20;
477 if (_FLAG_TEST_AND_CLEAR (Flags
, EFI_IFR_FLAG_OPTIONS_ONLY
)) {
478 mHeader
->Flags
|= EFI_IFR_FLAG_OPTIONS_ONLY
;
481 return _FLAGS_ZERO (Flags
) ? VFR_RETURN_SUCCESS
: VFR_RETURN_FLAGS_UNSUPPORTED
;
484 VOID
UpdateCIfrQuestionHeader (IN EFI_IFR_QUESTION_HEADER
*Header
) {
490 * The definition of CIfrMinMaxStepData
492 class CIfrMinMaxStepData
{
494 MINMAXSTEP_DATA
*mMinMaxStepData
;
499 CIfrMinMaxStepData (MINMAXSTEP_DATA
*DataAddr
, BOOLEAN NumericOpcode
=FALSE
) : mMinMaxStepData (DataAddr
) {
500 mMinMaxStepData
->u64
.MinValue
= 0;
501 mMinMaxStepData
->u64
.MaxValue
= 0;
502 mMinMaxStepData
->u64
.Step
= 0;
504 IsNumeric
= NumericOpcode
;
507 VOID
SetMinMaxStepData (IN UINT64 MinValue
, IN UINT64 MaxValue
, IN UINT64 Step
) {
509 mMinMaxStepData
->u64
.MinValue
= MinValue
;
510 mMinMaxStepData
->u64
.MaxValue
= MaxValue
;
513 if (MinValue
< mMinMaxStepData
->u64
.MinValue
) {
514 mMinMaxStepData
->u64
.MinValue
= MinValue
;
516 if (MaxValue
> mMinMaxStepData
->u64
.MaxValue
) {
517 mMinMaxStepData
->u64
.MaxValue
= MaxValue
;
520 mMinMaxStepData
->u64
.Step
= Step
;
523 VOID
SetMinMaxStepData (IN UINT32 MinValue
, IN UINT32 MaxValue
, IN UINT32 Step
) {
525 mMinMaxStepData
->u32
.MinValue
= MinValue
;
526 mMinMaxStepData
->u32
.MaxValue
= MaxValue
;
529 if (MinValue
< mMinMaxStepData
->u32
.MinValue
) {
530 mMinMaxStepData
->u32
.MinValue
= MinValue
;
532 if (MaxValue
> mMinMaxStepData
->u32
.MaxValue
) {
533 mMinMaxStepData
->u32
.MaxValue
= MaxValue
;
536 mMinMaxStepData
->u32
.Step
= Step
;
539 VOID
SetMinMaxStepData (IN UINT16 MinValue
, IN UINT16 MaxValue
, IN UINT16 Step
) {
541 mMinMaxStepData
->u16
.MinValue
= MinValue
;
542 mMinMaxStepData
->u16
.MaxValue
= MaxValue
;
545 if (MinValue
< mMinMaxStepData
->u16
.MinValue
) {
546 mMinMaxStepData
->u16
.MinValue
= MinValue
;
548 if (MaxValue
> mMinMaxStepData
->u16
.MaxValue
) {
549 mMinMaxStepData
->u16
.MaxValue
= MaxValue
;
552 mMinMaxStepData
->u16
.Step
= Step
;
555 VOID
SetMinMaxStepData (IN UINT8 MinValue
, IN UINT8 MaxValue
, IN UINT8 Step
) {
557 mMinMaxStepData
->u8
.MinValue
= MinValue
;
558 mMinMaxStepData
->u8
.MaxValue
= MaxValue
;
561 if (MinValue
< mMinMaxStepData
->u8
.MinValue
) {
562 mMinMaxStepData
->u8
.MinValue
= MinValue
;
564 if (MaxValue
> mMinMaxStepData
->u8
.MaxValue
) {
565 mMinMaxStepData
->u8
.MaxValue
= MaxValue
;
568 mMinMaxStepData
->u8
.Step
= Step
;
571 UINT64
GetMinData (UINT8 VarType
, BOOLEAN IsBitVar
) {
574 MinValue
= mMinMaxStepData
->u32
.MinValue
;
578 case EFI_IFR_TYPE_NUM_SIZE_64
:
579 MinValue
= mMinMaxStepData
->u64
.MinValue
;
581 case EFI_IFR_TYPE_NUM_SIZE_32
:
582 MinValue
= (UINT64
) mMinMaxStepData
->u32
.MinValue
;
584 case EFI_IFR_TYPE_NUM_SIZE_16
:
585 MinValue
= (UINT64
) mMinMaxStepData
->u16
.MinValue
;
587 case EFI_IFR_TYPE_NUM_SIZE_8
:
588 MinValue
= (UINT64
) mMinMaxStepData
->u8
.MinValue
;
596 UINT64
GetMaxData (UINT8 VarType
, BOOLEAN IsBitVar
) {
599 MaxValue
= mMinMaxStepData
->u32
.MaxValue
;
603 case EFI_IFR_TYPE_NUM_SIZE_64
:
604 MaxValue
= mMinMaxStepData
->u64
.MaxValue
;
606 case EFI_IFR_TYPE_NUM_SIZE_32
:
607 MaxValue
= (UINT64
) mMinMaxStepData
->u32
.MaxValue
;
609 case EFI_IFR_TYPE_NUM_SIZE_16
:
610 MaxValue
= (UINT64
) mMinMaxStepData
->u16
.MaxValue
;
612 case EFI_IFR_TYPE_NUM_SIZE_8
:
613 MaxValue
= (UINT64
) mMinMaxStepData
->u8
.MaxValue
;
621 UINT64
GetStepData (UINT8 VarType
, BOOLEAN IsBitVar
) {
624 MaxValue
= mMinMaxStepData
->u32
.Step
;
628 case EFI_IFR_TYPE_NUM_SIZE_64
:
629 MaxValue
= mMinMaxStepData
->u64
.Step
;
631 case EFI_IFR_TYPE_NUM_SIZE_32
:
632 MaxValue
= (UINT64
) mMinMaxStepData
->u32
.Step
;
634 case EFI_IFR_TYPE_NUM_SIZE_16
:
635 MaxValue
= (UINT64
) mMinMaxStepData
->u16
.Step
;
637 case EFI_IFR_TYPE_NUM_SIZE_8
:
638 MaxValue
= (UINT64
) mMinMaxStepData
->u8
.Step
;
646 BOOLEAN
IsNumericOpcode () {
650 VOID
UpdateCIfrMinMaxStepData (IN MINMAXSTEP_DATA
*MinMaxStepData
) {
651 mMinMaxStepData
= MinMaxStepData
;
655 static CIfrQuestionHeader
*gCurrentQuestion
= NULL
;
656 static CIfrMinMaxStepData
*gCurrentMinMaxData
= NULL
;
657 static BOOLEAN gIsOrderedList
= FALSE
;
658 static BOOLEAN gIsStringOp
= FALSE
;
661 * The definition of all of the UEFI IFR Objects
663 class CIfrFormSet
: public CIfrObj
, public CIfrOpHeader
{
665 EFI_IFR_FORM_SET
*mFormSet
;
666 EFI_GUID
*mClassGuid
;
669 CIfrFormSet (UINT8 Size
) : CIfrObj (EFI_IFR_FORM_SET_OP
, (CHAR8
**)NULL
, Size
),
670 CIfrOpHeader (EFI_IFR_FORM_SET_OP
, &(GetObjBinAddr
<EFI_IFR_FORM_SET
>())->Header
, Size
), mFormSet(GetObjBinAddr
<EFI_IFR_FORM_SET
>()) {
671 mFormSet
->Help
= EFI_STRING_ID_INVALID
;
672 mFormSet
->FormSetTitle
= EFI_STRING_ID_INVALID
;
674 memset (&mFormSet
->Guid
, 0, sizeof (EFI_GUID
));
675 mClassGuid
= (EFI_GUID
*) (mFormSet
+ 1);
678 VOID
SetGuid (IN EFI_GUID
*Guid
) {
679 memmove (&mFormSet
->Guid
, Guid
, sizeof (EFI_GUID
));
682 VOID
SetFormSetTitle (IN EFI_STRING_ID FormSetTitle
) {
683 mFormSet
->FormSetTitle
= FormSetTitle
;
686 VOID
SetHelp (IN EFI_STRING_ID Help
) {
687 mFormSet
->Help
= Help
;
690 VOID
SetClassGuid (IN EFI_GUID
*Guid
) {
691 memmove (&(mClassGuid
[mFormSet
->Flags
++]), Guid
, sizeof (EFI_GUID
));
695 return mFormSet
->Flags
;
699 class CIfrEnd
: public CIfrObj
, public CIfrOpHeader
{
701 CIfrEnd () : CIfrObj (EFI_IFR_END_OP
),
702 CIfrOpHeader (EFI_IFR_END_OP
, &(GetObjBinAddr
<EFI_IFR_END
>())->Header
) {}
705 class CIfrDefaultStore
: public CIfrObj
, public CIfrOpHeader
{
707 EFI_IFR_DEFAULTSTORE
*mDefaultStore
;
710 CIfrDefaultStore () : CIfrObj (EFI_IFR_DEFAULTSTORE_OP
),
711 CIfrOpHeader (EFI_IFR_DEFAULTSTORE_OP
, &(GetObjBinAddr
<EFI_IFR_DEFAULTSTORE
>())->Header
), mDefaultStore(GetObjBinAddr
<EFI_IFR_DEFAULTSTORE
>()) {
712 mDefaultStore
->DefaultId
= EFI_VARSTORE_ID_INVALID
;
713 mDefaultStore
->DefaultName
= EFI_STRING_ID_INVALID
;
716 VOID
SetDefaultName (IN EFI_STRING_ID DefaultName
) {
717 mDefaultStore
->DefaultName
= DefaultName
;
720 VOID
SetDefaultId (IN UINT16 DefaultId
) {
721 mDefaultStore
->DefaultId
= DefaultId
;
725 #define EFI_FORM_ID_MAX 0xFFFF
726 #define EFI_FREE_FORM_ID_BITMAP_SIZE ((EFI_FORM_ID_MAX + 1) / EFI_BITS_PER_UINT32)
730 STATIC UINT32 FormIdBitMap
[EFI_FREE_FORM_ID_BITMAP_SIZE
];
732 STATIC BOOLEAN
ChekFormIdFree (IN EFI_FORM_ID FormId
) {
733 UINT32 Index
= (FormId
/ EFI_BITS_PER_UINT32
);
734 UINT32 Offset
= (FormId
% EFI_BITS_PER_UINT32
);
736 return (FormIdBitMap
[Index
] & (0x80000000 >> Offset
)) == 0;
739 STATIC VOID
MarkFormIdUsed (IN EFI_FORM_ID FormId
) {
740 UINT32 Index
= (FormId
/ EFI_BITS_PER_UINT32
);
741 UINT32 Offset
= (FormId
% EFI_BITS_PER_UINT32
);
743 FormIdBitMap
[Index
] |= (0x80000000 >> Offset
);
747 class CIfrForm
: public CIfrObj
, public CIfrOpHeader
{
752 CIfrForm () : CIfrObj (EFI_IFR_FORM_OP
),
753 CIfrOpHeader (EFI_IFR_FORM_OP
, &(GetObjBinAddr
<EFI_IFR_FORM
>())->Header
), mForm(GetObjBinAddr
<EFI_IFR_FORM
>()) {
755 mForm
->FormTitle
= EFI_STRING_ID_INVALID
;
758 EFI_VFR_RETURN_CODE
SetFormId (IN EFI_FORM_ID FormId
) {
761 // FormId can't be 0.
763 return VFR_RETURN_INVALID_PARAMETER
;
765 if (CIfrFormId::ChekFormIdFree (FormId
) == FALSE
) {
766 return VFR_RETURN_FORMID_REDEFINED
;
768 mForm
->FormId
= FormId
;
769 CIfrFormId::MarkFormIdUsed (FormId
);
770 return VFR_RETURN_SUCCESS
;
773 VOID
SetFormTitle (IN EFI_STRING_ID FormTitle
) {
774 mForm
->FormTitle
= FormTitle
;
778 class CIfrFormMap
: public CIfrObj
, public CIfrOpHeader
{
780 EFI_IFR_FORM_MAP
*mFormMap
;
781 EFI_IFR_FORM_MAP_METHOD
*mMethodMap
;
784 CIfrFormMap () : CIfrObj (EFI_IFR_FORM_MAP_OP
, (CHAR8
**)NULL
, sizeof (EFI_IFR_FORM_MAP
), TRUE
),
785 CIfrOpHeader (EFI_IFR_FORM_MAP_OP
, &(GetObjBinAddr
<EFI_IFR_FORM_MAP
>())->Header
), mFormMap(GetObjBinAddr
<EFI_IFR_FORM_MAP
>()) {
786 mFormMap
->FormId
= 0;
787 mMethodMap
= (EFI_IFR_FORM_MAP_METHOD
*) (mFormMap
+ 1);
790 EFI_VFR_RETURN_CODE
SetFormId (IN EFI_FORM_ID FormId
) {
793 // FormId can't be 0.
795 return VFR_RETURN_INVALID_PARAMETER
;
797 if (CIfrFormId::ChekFormIdFree (FormId
) == FALSE
) {
798 return VFR_RETURN_FORMID_REDEFINED
;
800 mFormMap
->FormId
= FormId
;
801 CIfrFormId::MarkFormIdUsed (FormId
);
802 return VFR_RETURN_SUCCESS
;
805 VOID
SetFormMapMethod (IN EFI_STRING_ID MethodTitle
, IN EFI_GUID
*MethodGuid
) {
806 if (ExpendObjBin (sizeof (EFI_IFR_FORM_MAP_METHOD
))) {
807 IncLength (sizeof (EFI_IFR_FORM_MAP_METHOD
));
809 mMethodMap
->MethodTitle
= MethodTitle
;
810 memmove (&(mMethodMap
->MethodIdentifier
), MethodGuid
, sizeof (EFI_GUID
));
816 class CIfrVarStore
: public CIfrObj
, public CIfrOpHeader
{
818 EFI_IFR_VARSTORE
*mVarStore
;
821 CIfrVarStore () : CIfrObj (EFI_IFR_VARSTORE_OP
, (CHAR8
**)NULL
, sizeof (EFI_IFR_VARSTORE
), TRUE
),
822 CIfrOpHeader (EFI_IFR_VARSTORE_OP
, &(GetObjBinAddr
<EFI_IFR_VARSTORE
>())->Header
), mVarStore(GetObjBinAddr
<EFI_IFR_VARSTORE
>()) {
823 mVarStore
->VarStoreId
= EFI_VARSTORE_ID_INVALID
;
825 memset (&mVarStore
->Guid
, 0, sizeof (EFI_GUID
));
826 mVarStore
->Name
[0] = '\0';
829 VOID
SetGuid (IN EFI_GUID
*Guid
) {
830 memmove (&mVarStore
->Guid
, Guid
, sizeof (EFI_GUID
));
833 VOID
SetVarStoreId (IN EFI_VARSTORE_ID VarStoreId
) {
834 mVarStore
->VarStoreId
= VarStoreId
;
837 VOID
SetSize (IN UINT16 Size
) {
838 mVarStore
->Size
= Size
;
841 VOID
SetName (IN CHAR8
*Name
) {
845 Len
= (UINT8
) strlen (Name
);
847 if (ExpendObjBin (Len
) == TRUE
) {
849 strcpy ((CHAR8
*)(mVarStore
->Name
), Name
);
856 class CIfrVarStoreEfi
: public CIfrObj
, public CIfrOpHeader
{
858 EFI_IFR_VARSTORE_EFI
*mVarStoreEfi
;
861 CIfrVarStoreEfi () : CIfrObj (EFI_IFR_VARSTORE_EFI_OP
, (CHAR8
**)NULL
, sizeof (EFI_IFR_VARSTORE_EFI
), TRUE
),
862 CIfrOpHeader (EFI_IFR_VARSTORE_EFI_OP
, &(GetObjBinAddr
<EFI_IFR_VARSTORE_EFI
>())->Header
), mVarStoreEfi(GetObjBinAddr
<EFI_IFR_VARSTORE_EFI
>()) {
863 mVarStoreEfi
->VarStoreId
= EFI_VAROFFSET_INVALID
;
864 mVarStoreEfi
->Size
= 0;
865 memset (&mVarStoreEfi
->Guid
, 0, sizeof (EFI_GUID
));
866 mVarStoreEfi
->Name
[0] = '\0';
869 VOID
SetGuid (IN EFI_GUID
*Guid
) {
870 memmove (&mVarStoreEfi
->Guid
, Guid
, sizeof (EFI_GUID
));
873 VOID
SetVarStoreId (IN UINT16 VarStoreId
) {
874 mVarStoreEfi
->VarStoreId
= VarStoreId
;
877 VOID
SetAttributes (IN UINT32 Attributes
) {
878 mVarStoreEfi
->Attributes
= Attributes
;
880 VOID
SetSize (IN UINT16 Size
) {
881 mVarStoreEfi
->Size
= Size
;
884 VOID
SetName (IN CHAR8
*Name
) {
888 Len
= (UINT8
) strlen (Name
);
890 if (ExpendObjBin (Len
) == TRUE
) {
892 strcpy ((CHAR8
*)(mVarStoreEfi
->Name
), Name
);
898 VOID
SetBinaryLength (IN UINT16 Size
) {
901 Len
= sizeof (EFI_IFR_VARSTORE_EFI
);
903 ExpendObjBin(Size
- Len
);
904 IncLength(Size
- Len
);
906 ShrinkObjBin(Len
- Size
);
907 DecLength(Len
- Size
);
912 class CIfrVarStoreNameValue
: public CIfrObj
, public CIfrOpHeader
{
914 EFI_IFR_VARSTORE_NAME_VALUE
*mVarStoreNameValue
;
917 CIfrVarStoreNameValue () : CIfrObj (EFI_IFR_VARSTORE_NAME_VALUE_OP
),
918 CIfrOpHeader (EFI_IFR_VARSTORE_NAME_VALUE_OP
, &(GetObjBinAddr
<EFI_IFR_VARSTORE_NAME_VALUE
>())->Header
), mVarStoreNameValue(GetObjBinAddr
<EFI_IFR_VARSTORE_NAME_VALUE
>()) {
919 mVarStoreNameValue
->VarStoreId
= EFI_VAROFFSET_INVALID
;
920 memset (&mVarStoreNameValue
->Guid
, 0, sizeof (EFI_GUID
));
923 VOID
SetGuid (IN EFI_GUID
*Guid
) {
924 memmove (&mVarStoreNameValue
->Guid
, Guid
, sizeof (EFI_GUID
));
927 VOID
SetVarStoreId (IN UINT16 VarStoreId
) {
928 mVarStoreNameValue
->VarStoreId
= VarStoreId
;
932 class CIfrImage
: public CIfrObj
, public CIfrOpHeader
{
934 EFI_IFR_IMAGE
*mImage
;
937 CIfrImage () : CIfrObj (EFI_IFR_IMAGE_OP
),
938 CIfrOpHeader (EFI_IFR_IMAGE_OP
, &(GetObjBinAddr
<EFI_IFR_IMAGE
>())->Header
), mImage(GetObjBinAddr
<EFI_IFR_IMAGE
>()) {
939 mImage
->Id
= EFI_IMAGE_ID_INVALID
;
942 VOID
SetImageId (IN EFI_IMAGE_ID ImageId
) {
943 mImage
->Id
= ImageId
;
947 class CIfrModal
: public CIfrObj
, public CIfrOpHeader
{
949 CIfrModal () : CIfrObj (EFI_IFR_MODAL_TAG_OP
),
950 CIfrOpHeader (EFI_IFR_MODAL_TAG_OP
, &(GetObjBinAddr
<EFI_IFR_MODAL_TAG
>())->Header
) {
955 class CIfrLocked
: public CIfrObj
, public CIfrOpHeader
{
957 CIfrLocked () : CIfrObj (EFI_IFR_LOCKED_OP
),
958 CIfrOpHeader (EFI_IFR_LOCKED_OP
, &(GetObjBinAddr
<EFI_IFR_LOCKED
>())->Header
) {}
961 class CIfrRule
: public CIfrObj
, public CIfrOpHeader
{
966 CIfrRule () : CIfrObj (EFI_IFR_RULE_OP
),
967 CIfrOpHeader (EFI_IFR_RULE_OP
, &(GetObjBinAddr
<EFI_IFR_RULE
>())->Header
), mRule(GetObjBinAddr
<EFI_IFR_RULE
>()) {
968 mRule
->RuleId
= EFI_RULE_ID_INVALID
;
971 VOID
SetRuleId (IN UINT8 RuleId
) {
972 mRule
->RuleId
= RuleId
;
976 static EFI_IFR_TYPE_VALUE gZeroEfiIfrTypeValue
= {0, };
978 class CIfrDefault
: public CIfrObj
, public CIfrOpHeader
{
980 EFI_IFR_DEFAULT
*mDefault
;
985 IN UINT16 DefaultId
= EFI_HII_DEFAULT_CLASS_STANDARD
,
986 IN UINT8 Type
= EFI_IFR_TYPE_OTHER
,
987 IN EFI_IFR_TYPE_VALUE Value
= gZeroEfiIfrTypeValue
988 ) : CIfrObj (EFI_IFR_DEFAULT_OP
, (CHAR8
**)NULL
, Size
),
989 CIfrOpHeader (EFI_IFR_DEFAULT_OP
, &(GetObjBinAddr
<EFI_IFR_DEFAULT
>())->Header
, Size
), mDefault(GetObjBinAddr
<EFI_IFR_DEFAULT
>()) {
990 mDefault
->Type
= Type
;
991 mDefault
->DefaultId
= DefaultId
;
992 memmove (&(mDefault
->Value
), &Value
, Size
- OFFSET_OF (EFI_IFR_DEFAULT
, Value
));
995 VOID
SetDefaultId (IN UINT16 DefaultId
) {
996 mDefault
->DefaultId
= DefaultId
;
999 VOID
SetType (IN UINT8 Type
) {
1000 mDefault
->Type
= Type
;
1003 VOID
SetValue (IN EFI_IFR_TYPE_VALUE Value
) {
1004 memmove (&mDefault
->Value
, &Value
, mDefault
->Header
.Length
- OFFSET_OF (EFI_IFR_DEFAULT
, Value
));
1008 class CIfrDefault2
: public CIfrObj
, public CIfrOpHeader
{
1010 EFI_IFR_DEFAULT_2
*mDefault
;
1014 IN UINT16 DefaultId
= EFI_HII_DEFAULT_CLASS_STANDARD
,
1015 IN UINT8 Type
= EFI_IFR_TYPE_OTHER
1016 ) : CIfrObj (EFI_IFR_DEFAULT_OP
, (CHAR8
**)NULL
, sizeof (EFI_IFR_DEFAULT_2
)),
1017 CIfrOpHeader (EFI_IFR_DEFAULT_OP
, &(GetObjBinAddr
<EFI_IFR_DEFAULT_2
>())->Header
, sizeof (EFI_IFR_DEFAULT_2
)), mDefault(GetObjBinAddr
<EFI_IFR_DEFAULT_2
>()) {
1018 mDefault
->Type
= Type
;
1019 mDefault
->DefaultId
= DefaultId
;
1022 VOID
SetDefaultId (IN UINT16 DefaultId
) {
1023 mDefault
->DefaultId
= DefaultId
;
1026 VOID
SetType (IN UINT8 Type
) {
1027 mDefault
->Type
= Type
;
1031 class CIfrValue
: public CIfrObj
, public CIfrOpHeader
{
1033 CIfrValue () : CIfrObj (EFI_IFR_VALUE_OP
),
1034 CIfrOpHeader (EFI_IFR_VALUE_OP
, &(GetObjBinAddr
<EFI_IFR_VALUE
>())->Header
) {}
1038 class CIfrRead
: public CIfrObj
, public CIfrOpHeader
{
1040 CIfrRead () : CIfrObj (EFI_IFR_READ_OP
),
1041 CIfrOpHeader (EFI_IFR_READ_OP
, &(GetObjBinAddr
<EFI_IFR_READ
>())->Header
) {}
1045 class CIfrWrite
: public CIfrObj
, public CIfrOpHeader
{
1047 CIfrWrite () : CIfrObj (EFI_IFR_WRITE_OP
),
1048 CIfrOpHeader (EFI_IFR_WRITE_OP
, &(GetObjBinAddr
<EFI_IFR_WRITE
>())->Header
) {}
1052 class CIfrGet
: public CIfrObj
, public CIfrOpHeader
{
1059 ) : CIfrObj (EFI_IFR_GET_OP
),
1060 CIfrOpHeader (EFI_IFR_GET_OP
, &(GetObjBinAddr
<EFI_IFR_GET
>())->Header
), mGet(GetObjBinAddr
<EFI_IFR_GET
>()) {
1064 VOID
SetVarInfo (IN EFI_VARSTORE_INFO
*Info
) {
1065 mGet
->VarStoreId
= Info
->mVarStoreId
;
1066 mGet
->VarStoreInfo
.VarName
= Info
->mInfo
.mVarName
;
1067 mGet
->VarStoreInfo
.VarOffset
= Info
->mInfo
.mVarOffset
;
1068 mGet
->VarStoreType
= Info
->mVarType
;
1072 class CIfrSet
: public CIfrObj
, public CIfrOpHeader
{
1079 ) : CIfrObj (EFI_IFR_SET_OP
),
1080 CIfrOpHeader (EFI_IFR_SET_OP
, &(GetObjBinAddr
<EFI_IFR_SET
>())->Header
), mSet(GetObjBinAddr
<EFI_IFR_SET
>()) {
1084 VOID
SetVarInfo (IN EFI_VARSTORE_INFO
*Info
) {
1085 mSet
->VarStoreId
= Info
->mVarStoreId
;
1086 mSet
->VarStoreInfo
.VarName
= Info
->mInfo
.mVarName
;
1087 mSet
->VarStoreInfo
.VarOffset
= Info
->mInfo
.mVarOffset
;
1088 mSet
->VarStoreType
= Info
->mVarType
;
1092 class CIfrSubtitle
: public CIfrObj
, public CIfrOpHeader
, public CIfrStatementHeader
{
1094 EFI_IFR_SUBTITLE
*mSubtitle
;
1097 CIfrSubtitle () : CIfrObj (EFI_IFR_SUBTITLE_OP
),
1098 CIfrOpHeader (EFI_IFR_SUBTITLE_OP
, &(GetObjBinAddr
<EFI_IFR_SUBTITLE
>())->Header
),
1099 CIfrStatementHeader (&(GetObjBinAddr
<EFI_IFR_SUBTITLE
>())->Statement
), mSubtitle(GetObjBinAddr
<EFI_IFR_SUBTITLE
>()) {
1100 mSubtitle
->Flags
= 0;
1103 EFI_VFR_RETURN_CODE
SetFlags (IN UINT8 LFlags
) {
1104 if (_FLAG_TEST_AND_CLEAR (LFlags
, EFI_IFR_FLAGS_HORIZONTAL
)) {
1105 mSubtitle
->Flags
|= EFI_IFR_FLAGS_HORIZONTAL
;
1108 return _FLAGS_ZERO (LFlags
) ? VFR_RETURN_SUCCESS
: VFR_RETURN_FLAGS_UNSUPPORTED
;
1112 class CIfrText
: public CIfrObj
, public CIfrOpHeader
, public CIfrStatementHeader
{
1114 EFI_IFR_TEXT
*mText
;
1117 CIfrText () : CIfrObj (EFI_IFR_TEXT_OP
),
1118 CIfrOpHeader (EFI_IFR_TEXT_OP
, &(GetObjBinAddr
<EFI_IFR_TEXT
>())->Header
),
1119 CIfrStatementHeader (&(GetObjBinAddr
<EFI_IFR_TEXT
>())->Statement
), mText(GetObjBinAddr
<EFI_IFR_TEXT
>()) {
1120 mText
->TextTwo
= EFI_STRING_ID_INVALID
;
1123 VOID
SetTextTwo (IN EFI_STRING_ID StringId
) {
1124 mText
->TextTwo
= StringId
;
1128 class CIfrRef
: public CIfrObj
, public CIfrOpHeader
, public CIfrQuestionHeader
{
1133 CIfrRef () : CIfrObj (EFI_IFR_REF_OP
),
1134 CIfrOpHeader (EFI_IFR_REF_OP
, &(GetObjBinAddr
<EFI_IFR_REF
>())->Header
),
1135 CIfrQuestionHeader (&(GetObjBinAddr
<EFI_IFR_REF
>())->Question
), mRef(GetObjBinAddr
<EFI_IFR_REF
>()) {
1139 VOID
SetFormId (IN EFI_FORM_ID FormId
) {
1140 mRef
->FormId
= FormId
;
1144 class CIfrRef2
: public CIfrObj
, public CIfrOpHeader
, public CIfrQuestionHeader
{
1146 EFI_IFR_REF2
*mRef2
;
1149 CIfrRef2 () : CIfrObj (EFI_IFR_REF_OP
, (CHAR8
**)NULL
, sizeof (EFI_IFR_REF2
)),
1150 CIfrOpHeader (EFI_IFR_REF_OP
, &(GetObjBinAddr
<EFI_IFR_REF2
>())->Header
, sizeof (EFI_IFR_REF2
)),
1151 CIfrQuestionHeader (&(GetObjBinAddr
<EFI_IFR_REF2
>())->Question
), mRef2(GetObjBinAddr
<EFI_IFR_REF2
>()) {
1153 mRef2
->QuestionId
= EFI_QUESTION_ID_INVALID
;
1156 VOID
SetFormId (IN EFI_FORM_ID FormId
) {
1157 mRef2
->FormId
= FormId
;
1160 VOID
SetQuestionId (IN EFI_QUESTION_ID QuestionId
) {
1161 mRef2
->QuestionId
= QuestionId
;
1165 class CIfrRef3
: public CIfrObj
, public CIfrOpHeader
, public CIfrQuestionHeader
{
1167 EFI_IFR_REF3
*mRef3
;
1170 CIfrRef3 () : CIfrObj (EFI_IFR_REF_OP
, (CHAR8
**)NULL
, sizeof(EFI_IFR_REF3
)),
1171 CIfrOpHeader (EFI_IFR_REF_OP
, &(GetObjBinAddr
<EFI_IFR_REF3
>())->Header
, sizeof (EFI_IFR_REF3
)),
1172 CIfrQuestionHeader (&(GetObjBinAddr
<EFI_IFR_REF3
>())->Question
), mRef3(GetObjBinAddr
<EFI_IFR_REF3
>()) {
1174 mRef3
->QuestionId
= EFI_QUESTION_ID_INVALID
;
1175 memset (&mRef3
->FormSetId
, 0, sizeof (EFI_GUID
));
1178 VOID
SetFormId (IN EFI_FORM_ID FormId
) {
1179 mRef3
->FormId
= FormId
;
1182 VOID
SetQuestionId (IN EFI_QUESTION_ID QuestionId
) {
1183 mRef3
->QuestionId
= QuestionId
;
1186 VOID
SetFormSetId (IN EFI_GUID FormSetId
) {
1187 mRef3
->FormSetId
= FormSetId
;
1191 class CIfrRef4
: public CIfrObj
, public CIfrOpHeader
, public CIfrQuestionHeader
{
1193 EFI_IFR_REF4
*mRef4
;
1196 CIfrRef4 () : CIfrObj (EFI_IFR_REF_OP
, (CHAR8
**)NULL
, sizeof(EFI_IFR_REF4
)),
1197 CIfrOpHeader (EFI_IFR_REF_OP
, &(GetObjBinAddr
<EFI_IFR_REF4
>())->Header
, sizeof(EFI_IFR_REF4
)),
1198 CIfrQuestionHeader (&(GetObjBinAddr
<EFI_IFR_REF4
>())->Question
), mRef4(GetObjBinAddr
<EFI_IFR_REF4
>()) {
1200 mRef4
->QuestionId
= EFI_QUESTION_ID_INVALID
;
1201 memset (&mRef4
->FormSetId
, 0, sizeof (EFI_GUID
));
1202 mRef4
->DevicePath
= EFI_STRING_ID_INVALID
;
1205 VOID
SetFormId (IN EFI_FORM_ID FormId
) {
1206 mRef4
->FormId
= FormId
;
1209 VOID
SetQuestionId (IN EFI_QUESTION_ID QuestionId
) {
1210 mRef4
->QuestionId
= QuestionId
;
1213 VOID
SetFormSetId (IN EFI_GUID FormSetId
) {
1214 mRef4
->FormSetId
= FormSetId
;
1217 VOID
SetDevicePath (IN EFI_STRING_ID DevicePath
) {
1218 mRef4
->DevicePath
= DevicePath
;
1222 class CIfrRef5
: public CIfrObj
, public CIfrOpHeader
, public CIfrQuestionHeader
{
1224 CIfrRef5 () : CIfrObj (EFI_IFR_REF_OP
, (CHAR8
**)NULL
, sizeof (EFI_IFR_REF5
)),
1225 CIfrOpHeader (EFI_IFR_REF_OP
, &(GetObjBinAddr
<EFI_IFR_REF5
>())->Header
, sizeof (EFI_IFR_REF5
)),
1226 CIfrQuestionHeader (&(GetObjBinAddr
<EFI_IFR_REF5
>())->Question
) {
1230 class CIfrResetButton
: public CIfrObj
, public CIfrOpHeader
, public CIfrStatementHeader
{
1232 EFI_IFR_RESET_BUTTON
*mResetButton
;
1235 CIfrResetButton () : CIfrObj (EFI_IFR_RESET_BUTTON_OP
),
1236 CIfrOpHeader (EFI_IFR_RESET_BUTTON_OP
, &(GetObjBinAddr
<EFI_IFR_RESET_BUTTON
>())->Header
),
1237 CIfrStatementHeader (&(GetObjBinAddr
<EFI_IFR_RESET_BUTTON
>())->Statement
), mResetButton(GetObjBinAddr
<EFI_IFR_RESET_BUTTON
>()) {
1238 mResetButton
->DefaultId
= EFI_HII_DEFAULT_CLASS_STANDARD
;
1241 VOID
SetDefaultId (IN UINT16 DefaultId
) {
1242 mResetButton
->DefaultId
= DefaultId
;
1246 class CIfrCheckBox
: public CIfrObj
, public CIfrOpHeader
, public CIfrQuestionHeader
{
1248 EFI_IFR_CHECKBOX
*mCheckBox
;
1251 CIfrCheckBox () : CIfrObj (EFI_IFR_CHECKBOX_OP
),
1252 CIfrOpHeader (EFI_IFR_CHECKBOX_OP
, &(GetObjBinAddr
<EFI_IFR_CHECKBOX
>())->Header
),
1253 CIfrQuestionHeader (&(GetObjBinAddr
<EFI_IFR_CHECKBOX
>())->Question
), mCheckBox(GetObjBinAddr
<EFI_IFR_CHECKBOX
>()) {
1254 mCheckBox
->Flags
= 0;
1255 gCurrentQuestion
= this;
1259 gCurrentQuestion
= NULL
;
1262 EFI_VFR_RETURN_CODE
SetFlags (IN UINT8 HFlags
, UINT8 LFlags
) {
1263 EFI_VFR_RETURN_CODE Ret
;
1265 Ret
= CIfrQuestionHeader::SetFlags (HFlags
);
1266 if (Ret
!= VFR_RETURN_SUCCESS
) {
1270 if (_FLAG_TEST_AND_CLEAR (LFlags
, EFI_IFR_CHECKBOX_DEFAULT
)) {
1271 mCheckBox
->Flags
|= EFI_IFR_CHECKBOX_DEFAULT
;
1274 if (_FLAG_TEST_AND_CLEAR (LFlags
, EFI_IFR_CHECKBOX_DEFAULT_MFG
)) {
1275 mCheckBox
->Flags
|= EFI_IFR_CHECKBOX_DEFAULT_MFG
;
1278 return _FLAGS_ZERO (LFlags
) ? VFR_RETURN_SUCCESS
: VFR_RETURN_FLAGS_UNSUPPORTED
;
1281 UINT8
GetFlags (VOID
) {
1282 return mCheckBox
->Flags
;
1286 class CIfrAction
: public CIfrObj
, public CIfrOpHeader
, public CIfrQuestionHeader
{
1288 EFI_IFR_ACTION
*mAction
;
1291 CIfrAction () : CIfrObj (EFI_IFR_ACTION_OP
),
1292 CIfrOpHeader (EFI_IFR_ACTION_OP
, &(GetObjBinAddr
<EFI_IFR_ACTION
>())->Header
),
1293 CIfrQuestionHeader (&(GetObjBinAddr
<EFI_IFR_ACTION
>())->Question
), mAction(GetObjBinAddr
<EFI_IFR_ACTION
>()) {
1294 mAction
->QuestionConfig
= EFI_STRING_ID_INVALID
;
1297 VOID
SetQuestionConfig (IN EFI_STRING_ID QuestionConfig
) {
1298 mAction
->QuestionConfig
= QuestionConfig
;
1302 class CIfrDate
: public CIfrObj
, public CIfrOpHeader
, public CIfrQuestionHeader
{
1304 EFI_IFR_DATE
*mDate
;
1307 CIfrDate () : CIfrObj (EFI_IFR_DATE_OP
),
1308 CIfrOpHeader (EFI_IFR_DATE_OP
, &(GetObjBinAddr
<EFI_IFR_DATE
>())->Header
),
1309 CIfrQuestionHeader (&(GetObjBinAddr
<EFI_IFR_DATE
>())->Question
), mDate(GetObjBinAddr
<EFI_IFR_DATE
>()) {
1313 EFI_VFR_RETURN_CODE
SetFlags (IN UINT8 HFlags
, IN UINT8 LFlags
) {
1314 EFI_VFR_RETURN_CODE Ret
;
1316 Ret
= CIfrQuestionHeader::SetFlags (HFlags
);
1317 if (Ret
!= VFR_RETURN_SUCCESS
) {
1321 if (_FLAG_TEST_AND_CLEAR (LFlags
, EFI_QF_DATE_YEAR_SUPPRESS
)) {
1322 mDate
->Flags
|= EFI_QF_DATE_YEAR_SUPPRESS
;
1325 if (_FLAG_TEST_AND_CLEAR (LFlags
, EFI_QF_DATE_MONTH_SUPPRESS
)) {
1326 mDate
->Flags
|= EFI_QF_DATE_MONTH_SUPPRESS
;
1329 if (_FLAG_TEST_AND_CLEAR (LFlags
, EFI_QF_DATE_DAY_SUPPRESS
)) {
1330 mDate
->Flags
|= EFI_QF_DATE_DAY_SUPPRESS
;
1333 if (_FLAG_TEST_AND_CLEAR (LFlags
, QF_DATE_STORAGE_NORMAL
)) {
1334 mDate
->Flags
|= QF_DATE_STORAGE_NORMAL
;
1335 } else if (_FLAG_TEST_AND_CLEAR (LFlags
, QF_DATE_STORAGE_TIME
)) {
1336 mDate
->Flags
|= QF_DATE_STORAGE_TIME
;
1337 } else if (_FLAG_TEST_AND_CLEAR (LFlags
, QF_DATE_STORAGE_WAKEUP
)) {
1338 mDate
->Flags
|= QF_DATE_STORAGE_WAKEUP
;
1341 return _FLAGS_ZERO (LFlags
) ? VFR_RETURN_SUCCESS
: VFR_RETURN_FLAGS_UNSUPPORTED
;
1345 class CIfrNumeric
: public CIfrObj
, public CIfrOpHeader
, public CIfrQuestionHeader
, public CIfrMinMaxStepData
{
1347 EFI_IFR_NUMERIC
*mNumeric
;
1350 CIfrNumeric () : CIfrObj (EFI_IFR_NUMERIC_OP
, (CHAR8
**)NULL
, sizeof (EFI_IFR_NUMERIC
), TRUE
),
1351 CIfrOpHeader (EFI_IFR_NUMERIC_OP
, &(GetObjBinAddr
<EFI_IFR_NUMERIC
>())->Header
),
1352 CIfrQuestionHeader (&(GetObjBinAddr
<EFI_IFR_NUMERIC
>())->Question
),
1353 CIfrMinMaxStepData (&(GetObjBinAddr
<EFI_IFR_NUMERIC
>())->data
, TRUE
), mNumeric(GetObjBinAddr
<EFI_IFR_NUMERIC
>()) {
1354 mNumeric
->Flags
= EFI_IFR_NUMERIC_SIZE_1
| EFI_IFR_DISPLAY_UINT_DEC
;
1355 gCurrentQuestion
= this;
1356 gCurrentMinMaxData
= this;
1360 gCurrentQuestion
= NULL
;
1361 gCurrentMinMaxData
= NULL
;
1364 VOID
ShrinkBinSize (IN UINT16 Size
) {
1366 // Update the buffer size which is truly be used later.
1372 // Allocate buffer in gCFormPkg.
1374 _EMIT_PENDING_OBJ();
1377 // Update the buffer pointer used by other class.
1379 mNumeric
= GetObjBinAddr
<EFI_IFR_NUMERIC
>();
1380 UpdateHeader (&mNumeric
->Header
);
1381 UpdateCIfrQuestionHeader(&mNumeric
->Question
);
1382 UpdateCIfrMinMaxStepData(&mNumeric
->data
);
1385 EFI_VFR_RETURN_CODE
SetFlags (IN UINT8 HFlags
, IN UINT8 LFlags
, BOOLEAN DisplaySettingsSpecified
= FALSE
) {
1386 EFI_VFR_RETURN_CODE Ret
;
1388 Ret
= CIfrQuestionHeader::SetFlags (HFlags
);
1389 if (Ret
!= VFR_RETURN_SUCCESS
) {
1393 if (DisplaySettingsSpecified
== FALSE
) {
1394 mNumeric
->Flags
= LFlags
| EFI_IFR_DISPLAY_UINT_DEC
;
1396 mNumeric
->Flags
= LFlags
;
1398 return VFR_RETURN_SUCCESS
;
1401 EFI_VFR_RETURN_CODE
SetFlagsForBitField (IN UINT8 HFlags
, IN UINT8 LFlags
, BOOLEAN DisplaySettingsSpecified
= FALSE
) {
1402 EFI_VFR_RETURN_CODE Ret
;
1404 Ret
= CIfrQuestionHeader::SetFlags (HFlags
);
1405 if (Ret
!= VFR_RETURN_SUCCESS
) {
1409 if (DisplaySettingsSpecified
== FALSE
) {
1410 mNumeric
->Flags
= LFlags
| EDKII_IFR_DISPLAY_UINT_DEC_BIT
;
1412 mNumeric
->Flags
= LFlags
;
1414 return VFR_RETURN_SUCCESS
;
1417 UINT8
GetNumericFlags () {
1418 return mNumeric
->Flags
;
1422 class CIfrOneOf
: public CIfrObj
, public CIfrOpHeader
, public CIfrQuestionHeader
, public CIfrMinMaxStepData
{
1424 EFI_IFR_ONE_OF
*mOneOf
;
1427 CIfrOneOf () : CIfrObj (EFI_IFR_ONE_OF_OP
, (CHAR8
**)NULL
, sizeof (EFI_IFR_ONE_OF
), TRUE
),
1428 CIfrOpHeader (EFI_IFR_ONE_OF_OP
, &(GetObjBinAddr
<EFI_IFR_ONE_OF
>())->Header
),
1429 CIfrQuestionHeader (&(GetObjBinAddr
<EFI_IFR_ONE_OF
>())->Question
),
1430 CIfrMinMaxStepData (&(GetObjBinAddr
<EFI_IFR_ONE_OF
>())->data
), mOneOf(GetObjBinAddr
<EFI_IFR_ONE_OF
>()) {
1432 gCurrentQuestion
= this;
1433 gCurrentMinMaxData
= this;
1437 gCurrentQuestion
= NULL
;
1438 gCurrentMinMaxData
= NULL
;
1441 EFI_VFR_RETURN_CODE
SetFlags (IN UINT8 HFlags
, IN UINT8 LFlags
) {
1442 EFI_VFR_RETURN_CODE Ret
;
1444 Ret
= CIfrQuestionHeader::SetFlags (HFlags
);
1445 if (Ret
!= VFR_RETURN_SUCCESS
) {
1449 if (LFlags
& EFI_IFR_DISPLAY
) {
1450 mOneOf
->Flags
= LFlags
;
1452 mOneOf
->Flags
= LFlags
| EFI_IFR_DISPLAY_UINT_DEC
;
1454 return VFR_RETURN_SUCCESS
;
1457 EFI_VFR_RETURN_CODE
SetFlagsForBitField (IN UINT8 HFlags
, IN UINT8 LFlags
) {
1458 EFI_VFR_RETURN_CODE Ret
;
1460 Ret
= CIfrQuestionHeader::SetFlags (HFlags
);
1461 if (Ret
!= VFR_RETURN_SUCCESS
) {
1465 if (LFlags
& EFI_IFR_DISPLAY
) {
1466 mOneOf
->Flags
= LFlags
;
1468 mOneOf
->Flags
= LFlags
| EDKII_IFR_DISPLAY_UINT_DEC_BIT
;
1470 return VFR_RETURN_SUCCESS
;
1473 VOID
ShrinkBinSize (IN UINT16 Size
) {
1475 // Update the buffer size which is truly be used later.
1481 // Allocate buffer in gCFormPkg.
1483 _EMIT_PENDING_OBJ();
1486 // Update the buffer pointer used by other class.
1488 mOneOf
= GetObjBinAddr
<EFI_IFR_ONE_OF
>();
1489 UpdateHeader (&mOneOf
->Header
);
1490 UpdateCIfrQuestionHeader(&mOneOf
->Question
);
1491 UpdateCIfrMinMaxStepData(&mOneOf
->data
);
1495 class CIfrString
: public CIfrObj
, public CIfrOpHeader
, public CIfrQuestionHeader
{
1497 EFI_IFR_STRING
*mString
;
1500 CIfrString () : CIfrObj (EFI_IFR_STRING_OP
),
1501 CIfrOpHeader (EFI_IFR_STRING_OP
, &(GetObjBinAddr
<EFI_IFR_STRING
>())->Header
),
1502 CIfrQuestionHeader (&(GetObjBinAddr
<EFI_IFR_STRING
>())->Question
), mString(GetObjBinAddr
<EFI_IFR_STRING
>()) {
1504 mString
->MinSize
= 0;
1505 mString
->MaxSize
= 0;
1506 gCurrentQuestion
= this;
1510 gCurrentQuestion
= NULL
;
1513 EFI_VFR_RETURN_CODE
SetFlags (IN UINT8 HFlags
, IN UINT8 LFlags
) {
1514 EFI_VFR_RETURN_CODE Ret
;
1516 Ret
= CIfrQuestionHeader::SetFlags (HFlags
);
1517 if (Ret
!= VFR_RETURN_SUCCESS
) {
1521 if (_FLAG_TEST_AND_CLEAR (LFlags
, EFI_IFR_STRING_MULTI_LINE
)) {
1522 mString
->Flags
|= EFI_IFR_STRING_MULTI_LINE
;
1525 return _FLAGS_ZERO (LFlags
) ? VFR_RETURN_SUCCESS
: VFR_RETURN_FLAGS_UNSUPPORTED
;
1528 VOID
SetMinSize (IN UINT8 Flags
) {
1529 mString
->MinSize
= Flags
;
1532 VOID
SetMaxSize (IN UINT8 MaxSize
) {
1533 mString
->MaxSize
= MaxSize
;
1537 class CIfrPassword
: public CIfrObj
, public CIfrOpHeader
, public CIfrQuestionHeader
{
1539 EFI_IFR_PASSWORD
*mPassword
;
1542 CIfrPassword () : CIfrObj (EFI_IFR_PASSWORD_OP
),
1543 CIfrOpHeader (EFI_IFR_PASSWORD_OP
, &(GetObjBinAddr
<EFI_IFR_PASSWORD
>())->Header
),
1544 CIfrQuestionHeader (&(GetObjBinAddr
<EFI_IFR_PASSWORD
>())->Question
), mPassword(GetObjBinAddr
<EFI_IFR_PASSWORD
>()) {
1545 mPassword
->MinSize
= 0;
1546 mPassword
->MaxSize
= 0;
1547 gCurrentQuestion
= this;
1551 gCurrentQuestion
= NULL
;
1554 VOID
SetMinSize (IN UINT16 MinSize
) {
1555 mPassword
->MinSize
= MinSize
;
1558 VOID
SetMaxSize (IN UINT16 MaxSize
) {
1559 mPassword
->MaxSize
= MaxSize
;
1563 class CIfrOrderedList
: public CIfrObj
, public CIfrOpHeader
, public CIfrQuestionHeader
{
1565 EFI_IFR_ORDERED_LIST
*mOrderedList
;
1568 CIfrOrderedList () : CIfrObj (EFI_IFR_ORDERED_LIST_OP
),
1569 CIfrOpHeader (EFI_IFR_ORDERED_LIST_OP
, &(GetObjBinAddr
<EFI_IFR_ORDERED_LIST
>())->Header
),
1570 CIfrQuestionHeader (&(GetObjBinAddr
<EFI_IFR_ORDERED_LIST
>())->Question
), mOrderedList(GetObjBinAddr
<EFI_IFR_ORDERED_LIST
>()) {
1571 mOrderedList
->MaxContainers
= 0;
1572 mOrderedList
->Flags
= 0;
1573 gCurrentQuestion
= this;
1576 ~CIfrOrderedList () {
1577 gCurrentQuestion
= NULL
;
1580 VOID
SetMaxContainers (IN UINT8 MaxContainers
) {
1581 mOrderedList
->MaxContainers
= MaxContainers
;
1584 EFI_VFR_RETURN_CODE
SetFlags (IN UINT8 HFlags
, IN UINT8 LFlags
) {
1585 EFI_VFR_RETURN_CODE Ret
;
1587 Ret
= CIfrQuestionHeader::SetFlags (HFlags
);
1588 if (Ret
!= VFR_RETURN_SUCCESS
) {
1592 if (_FLAG_TEST_AND_CLEAR (LFlags
, EFI_IFR_UNIQUE_SET
)) {
1593 mOrderedList
->Flags
|= EFI_IFR_UNIQUE_SET
;
1596 if (_FLAG_TEST_AND_CLEAR (LFlags
, EFI_IFR_NO_EMPTY_SET
)) {
1597 mOrderedList
->Flags
|= EFI_IFR_NO_EMPTY_SET
;
1600 return _FLAGS_ZERO (LFlags
) ? VFR_RETURN_SUCCESS
: VFR_RETURN_FLAGS_UNSUPPORTED
;
1604 class CIfrTime
: public CIfrObj
, public CIfrOpHeader
, public CIfrQuestionHeader
{
1606 EFI_IFR_TIME
*mTime
;
1609 CIfrTime () : CIfrObj (EFI_IFR_TIME_OP
),
1610 CIfrOpHeader (EFI_IFR_TIME_OP
, &(GetObjBinAddr
<EFI_IFR_TIME
>())->Header
),
1611 CIfrQuestionHeader (&(GetObjBinAddr
<EFI_IFR_TIME
>())->Question
), mTime(GetObjBinAddr
<EFI_IFR_TIME
>()) {
1615 EFI_VFR_RETURN_CODE
SetFlags (IN UINT8 HFlags
, IN UINT8 LFlags
) {
1616 EFI_VFR_RETURN_CODE Ret
;
1618 Ret
= CIfrQuestionHeader::SetFlags (HFlags
);
1619 if (Ret
!= VFR_RETURN_SUCCESS
) {
1623 if (_FLAG_TEST_AND_CLEAR (LFlags
, QF_TIME_HOUR_SUPPRESS
)) {
1624 mTime
->Flags
|= QF_TIME_HOUR_SUPPRESS
;
1627 if (_FLAG_TEST_AND_CLEAR (LFlags
, QF_TIME_MINUTE_SUPPRESS
)) {
1628 mTime
->Flags
|= QF_TIME_MINUTE_SUPPRESS
;
1631 if (_FLAG_TEST_AND_CLEAR (LFlags
, QF_TIME_SECOND_SUPPRESS
)) {
1632 mTime
->Flags
|= QF_TIME_SECOND_SUPPRESS
;
1635 if (_FLAG_TEST_AND_CLEAR (LFlags
, QF_TIME_STORAGE_NORMAL
)) {
1636 mTime
->Flags
|= QF_TIME_STORAGE_NORMAL
;
1637 } else if (_FLAG_TEST_AND_CLEAR (LFlags
, QF_TIME_STORAGE_TIME
)) {
1638 mTime
->Flags
|= QF_TIME_STORAGE_TIME
;
1639 } else if (_FLAG_TEST_AND_CLEAR (LFlags
, QF_TIME_STORAGE_WAKEUP
)) {
1640 mTime
->Flags
|= QF_TIME_STORAGE_WAKEUP
;
1643 return _FLAGS_ZERO (LFlags
) ? VFR_RETURN_SUCCESS
: VFR_RETURN_FLAGS_UNSUPPORTED
;
1647 class CIfrDisableIf
: public CIfrObj
, public CIfrOpHeader
{
1649 CIfrDisableIf () : CIfrObj (EFI_IFR_DISABLE_IF_OP
),
1650 CIfrOpHeader (EFI_IFR_DISABLE_IF_OP
, &(GetObjBinAddr
<EFI_IFR_DISABLE_IF
>())->Header
) {}
1653 class CIfrSuppressIf
: public CIfrObj
, public CIfrOpHeader
{
1655 CIfrSuppressIf () : CIfrObj (EFI_IFR_SUPPRESS_IF_OP
),
1656 CIfrOpHeader (EFI_IFR_SUPPRESS_IF_OP
, &(GetObjBinAddr
<EFI_IFR_SUPPRESS_IF
>())->Header
) {}
1659 class CIfrGrayOutIf
: public CIfrObj
, public CIfrOpHeader
{
1661 CIfrGrayOutIf () : CIfrObj (EFI_IFR_GRAY_OUT_IF_OP
),
1662 CIfrOpHeader (EFI_IFR_GRAY_OUT_IF_OP
, &(GetObjBinAddr
<EFI_IFR_GRAY_OUT_IF
>())->Header
) {}
1665 class CIfrInconsistentIf
: public CIfrObj
, public CIfrOpHeader
{
1667 EFI_IFR_INCONSISTENT_IF
*mInconsistentIf
;
1670 CIfrInconsistentIf () : CIfrObj (EFI_IFR_INCONSISTENT_IF_OP
),
1671 CIfrOpHeader (EFI_IFR_INCONSISTENT_IF_OP
, &(GetObjBinAddr
<EFI_IFR_INCONSISTENT_IF
>())->Header
), mInconsistentIf(GetObjBinAddr
<EFI_IFR_INCONSISTENT_IF
>()) {
1672 mInconsistentIf
->Error
= EFI_STRING_ID_INVALID
;
1675 VOID
SetError (IN EFI_STRING_ID Error
) {
1676 mInconsistentIf
->Error
= Error
;
1680 class CIfrWarningIf
: public CIfrObj
, public CIfrOpHeader
{
1682 EFI_IFR_WARNING_IF
*mWarningIf
;
1685 CIfrWarningIf () : CIfrObj (EFI_IFR_WARNING_IF_OP
),
1686 CIfrOpHeader (EFI_IFR_WARNING_IF_OP
, &(GetObjBinAddr
<EFI_IFR_WARNING_IF
>())->Header
), mWarningIf(GetObjBinAddr
<EFI_IFR_WARNING_IF
>()) {
1687 mWarningIf
->Warning
= EFI_STRING_ID_INVALID
;
1688 mWarningIf
->TimeOut
= 0;
1691 VOID
SetWarning (IN EFI_STRING_ID Warning
) {
1692 mWarningIf
->Warning
= Warning
;
1695 VOID
SetTimeOut (IN UINT8 TimeOut
) {
1696 mWarningIf
->TimeOut
= TimeOut
;
1700 class CIfrNoSubmitIf
: public CIfrObj
, public CIfrOpHeader
{
1702 EFI_IFR_NO_SUBMIT_IF
*mNoSubmitIf
;
1705 CIfrNoSubmitIf () : CIfrObj (EFI_IFR_NO_SUBMIT_IF_OP
),
1706 CIfrOpHeader (EFI_IFR_NO_SUBMIT_IF_OP
, &(GetObjBinAddr
<EFI_IFR_NO_SUBMIT_IF
>())->Header
), mNoSubmitIf(GetObjBinAddr
<EFI_IFR_NO_SUBMIT_IF
>()) {
1707 mNoSubmitIf
->Error
= EFI_STRING_ID_INVALID
;
1710 VOID
SetError (IN EFI_STRING_ID Error
) {
1711 mNoSubmitIf
->Error
= Error
;
1715 class CIfrRefresh
: public CIfrObj
, public CIfrOpHeader
{
1717 EFI_IFR_REFRESH
*mRefresh
;
1720 CIfrRefresh () : CIfrObj (EFI_IFR_REFRESH_OP
),
1721 CIfrOpHeader (EFI_IFR_REFRESH_OP
, &(GetObjBinAddr
<EFI_IFR_REFRESH
>())->Header
), mRefresh(GetObjBinAddr
<EFI_IFR_REFRESH
>()) {
1722 mRefresh
->RefreshInterval
= 0;
1725 VOID
SetRefreshInterval (IN UINT8 RefreshInterval
) {
1726 mRefresh
->RefreshInterval
= RefreshInterval
;
1730 class CIfrRefreshId
: public CIfrObj
, public CIfrOpHeader
{
1732 EFI_IFR_REFRESH_ID
*mRefreshId
;
1735 CIfrRefreshId () : CIfrObj (EFI_IFR_REFRESH_ID_OP
),
1736 CIfrOpHeader (EFI_IFR_REFRESH_ID_OP
, &(GetObjBinAddr
<EFI_IFR_REFRESH_ID
>())->Header
), mRefreshId(GetObjBinAddr
<EFI_IFR_REFRESH_ID
>()) {
1737 memset (&mRefreshId
->RefreshEventGroupId
, 0, sizeof (EFI_GUID
));
1740 VOID
SetRefreshEventGroutId (IN EFI_GUID
*RefreshEventGroupId
) {
1741 memmove (&mRefreshId
->RefreshEventGroupId
, RefreshEventGroupId
, sizeof (EFI_GUID
));
1745 class CIfrVarStoreDevice
: public CIfrObj
, public CIfrOpHeader
{
1747 EFI_IFR_VARSTORE_DEVICE
*mVarStoreDevice
;
1750 CIfrVarStoreDevice () : CIfrObj (EFI_IFR_VARSTORE_DEVICE_OP
),
1751 CIfrOpHeader (EFI_IFR_VARSTORE_DEVICE_OP
, &(GetObjBinAddr
<EFI_IFR_VARSTORE_DEVICE
>())->Header
), mVarStoreDevice(GetObjBinAddr
<EFI_IFR_VARSTORE_DEVICE
>()) {
1752 mVarStoreDevice
->DevicePath
= EFI_STRING_ID_INVALID
;
1755 VOID
SetDevicePath (IN EFI_STRING_ID DevicePath
) {
1756 mVarStoreDevice
->DevicePath
= DevicePath
;
1760 class CIfrOneOfOption
: public CIfrObj
, public CIfrOpHeader
{
1762 EFI_IFR_ONE_OF_OPTION
*mOneOfOption
;
1765 CIfrOneOfOption (UINT8 Size
) : CIfrObj (EFI_IFR_ONE_OF_OPTION_OP
, (CHAR8
**)NULL
, Size
),
1766 CIfrOpHeader (EFI_IFR_ONE_OF_OPTION_OP
, &(GetObjBinAddr
<EFI_IFR_ONE_OF_OPTION
>())->Header
, Size
), mOneOfOption(GetObjBinAddr
<EFI_IFR_ONE_OF_OPTION
>()) {
1767 mOneOfOption
->Flags
= 0;
1768 mOneOfOption
->Option
= EFI_STRING_ID_INVALID
;
1769 mOneOfOption
->Type
= EFI_IFR_TYPE_OTHER
;
1770 memset (&mOneOfOption
->Value
, 0, Size
- OFFSET_OF (EFI_IFR_ONE_OF_OPTION
, Value
));
1773 VOID
SetOption (IN EFI_STRING_ID Option
) {
1774 mOneOfOption
->Option
= Option
;
1777 EFI_VFR_RETURN_CODE
SetFlags (IN UINT8 LFlags
) {
1778 mOneOfOption
->Flags
= 0;
1779 if (_FLAG_TEST_AND_CLEAR (LFlags
, EFI_IFR_OPTION_DEFAULT
)) {
1780 mOneOfOption
->Flags
|= EFI_IFR_OPTION_DEFAULT
;
1783 if (_FLAG_TEST_AND_CLEAR (LFlags
, EFI_IFR_OPTION_DEFAULT_MFG
)) {
1784 mOneOfOption
->Flags
|= EFI_IFR_OPTION_DEFAULT_MFG
;
1787 if (_IS_EQUAL (LFlags
, EFI_IFR_TYPE_NUM_SIZE_8
)) {
1788 _FLAG_CLEAR (LFlags
, EFI_IFR_TYPE_NUM_SIZE_8
);
1789 mOneOfOption
->Flags
|= EFI_IFR_TYPE_NUM_SIZE_8
;
1790 } else if (_IS_EQUAL (LFlags
, EFI_IFR_TYPE_NUM_SIZE_16
)) {
1791 _FLAG_CLEAR (LFlags
, EFI_IFR_TYPE_NUM_SIZE_16
);
1792 mOneOfOption
->Flags
|= EFI_IFR_TYPE_NUM_SIZE_16
;
1793 } else if (_IS_EQUAL (LFlags
, EFI_IFR_TYPE_NUM_SIZE_32
)) {
1794 _FLAG_CLEAR (LFlags
, EFI_IFR_TYPE_NUM_SIZE_32
);
1795 mOneOfOption
->Flags
|= EFI_IFR_TYPE_NUM_SIZE_32
;
1796 } else if (_IS_EQUAL (LFlags
, EFI_IFR_TYPE_NUM_SIZE_64
)) {
1797 _FLAG_CLEAR (LFlags
, EFI_IFR_TYPE_NUM_SIZE_64
);
1798 mOneOfOption
->Flags
|= EFI_IFR_TYPE_NUM_SIZE_64
;
1799 } else if (_IS_EQUAL (LFlags
, EFI_IFR_TYPE_BOOLEAN
)) {
1800 _FLAG_CLEAR (LFlags
, EFI_IFR_TYPE_BOOLEAN
);
1801 mOneOfOption
->Flags
|= EFI_IFR_TYPE_BOOLEAN
;
1802 } else if (_IS_EQUAL (LFlags
, EFI_IFR_TYPE_TIME
)) {
1803 _FLAG_CLEAR (LFlags
, EFI_IFR_TYPE_TIME
);
1804 mOneOfOption
->Flags
|= EFI_IFR_TYPE_TIME
;
1805 } else if (_IS_EQUAL (LFlags
, EFI_IFR_TYPE_DATE
)) {
1806 _FLAG_CLEAR (LFlags
, EFI_IFR_TYPE_DATE
);
1807 mOneOfOption
->Flags
|= EFI_IFR_TYPE_DATE
;
1808 } else if (_IS_EQUAL (LFlags
, EFI_IFR_TYPE_STRING
)) {
1809 _FLAG_CLEAR (LFlags
, EFI_IFR_TYPE_STRING
);
1810 mOneOfOption
->Flags
|= EFI_IFR_TYPE_STRING
;
1811 } else if (_IS_EQUAL (LFlags
, EFI_IFR_TYPE_OTHER
)) {
1812 _FLAG_CLEAR (LFlags
, EFI_IFR_TYPE_OTHER
);
1813 mOneOfOption
->Flags
|= EFI_IFR_TYPE_OTHER
;
1816 return _FLAGS_ZERO (LFlags
) ? VFR_RETURN_SUCCESS
: VFR_RETURN_FLAGS_UNSUPPORTED
;
1819 VOID
SetType (IN UINT8 Type
) {
1820 mOneOfOption
->Type
= Type
;
1823 VOID
SetValue (IN EFI_IFR_TYPE_VALUE Value
) {
1824 memmove (&mOneOfOption
->Value
, &Value
, mOneOfOption
->Header
.Length
- OFFSET_OF (EFI_IFR_ONE_OF_OPTION
, Value
));
1827 UINT8
GetFlags (VOID
) {
1828 return mOneOfOption
->Flags
;
1832 static EFI_GUID IfrTianoGuid
= EFI_IFR_TIANO_GUID
;
1833 static EFI_GUID IfrFrameworkGuid
= EFI_IFR_FRAMEWORK_GUID
;
1835 class CIfrClass
: public CIfrObj
, public CIfrOpHeader
{
1837 EFI_IFR_GUID_CLASS
*mClass
;
1840 CIfrClass () : CIfrObj (EFI_IFR_GUID_OP
, (CHAR8
**)NULL
, sizeof (EFI_IFR_GUID_CLASS
)),
1841 CIfrOpHeader (EFI_IFR_GUID_OP
, &(GetObjBinAddr
<EFI_IFR_GUID_CLASS
>())->Header
, sizeof (EFI_IFR_GUID_CLASS
)), mClass(GetObjBinAddr
<EFI_IFR_GUID_CLASS
>()) {
1842 mClass
->ExtendOpCode
= EFI_IFR_EXTEND_OP_CLASS
;
1843 mClass
->Guid
= IfrTianoGuid
;
1844 mClass
->Class
= EFI_NON_DEVICE_CLASS
;
1847 VOID
SetClass (IN UINT16 Class
) {
1848 mClass
->Class
= Class
;
1852 class CIfrSubClass
: public CIfrObj
, public CIfrOpHeader
{
1854 EFI_IFR_GUID_SUBCLASS
*mSubClass
;
1857 CIfrSubClass () : CIfrObj (EFI_IFR_GUID_OP
, (CHAR8
**)NULL
, sizeof (EFI_IFR_GUID_SUBCLASS
)),
1858 CIfrOpHeader (EFI_IFR_GUID_OP
, &(GetObjBinAddr
<EFI_IFR_GUID_SUBCLASS
>())->Header
, sizeof (EFI_IFR_GUID_SUBCLASS
)), mSubClass(GetObjBinAddr
<EFI_IFR_GUID_SUBCLASS
>()) {
1859 mSubClass
->ExtendOpCode
= EFI_IFR_EXTEND_OP_SUBCLASS
;
1860 mSubClass
->Guid
= IfrTianoGuid
;
1861 mSubClass
->SubClass
= EFI_SETUP_APPLICATION_SUBCLASS
;
1864 VOID
SetSubClass (IN UINT16 SubClass
) {
1865 mSubClass
->SubClass
= SubClass
;
1869 class CIfrLabel
: public CIfrObj
, public CIfrOpHeader
{
1871 EFI_IFR_GUID_LABEL
*mLabel
;
1874 CIfrLabel () : CIfrObj (EFI_IFR_GUID_OP
, (CHAR8
**)NULL
, sizeof (EFI_IFR_GUID_LABEL
)),
1875 CIfrOpHeader (EFI_IFR_GUID_OP
, &(GetObjBinAddr
<EFI_IFR_GUID_LABEL
>())->Header
, sizeof (EFI_IFR_GUID_LABEL
)), mLabel(GetObjBinAddr
<EFI_IFR_GUID_LABEL
>()) {
1876 mLabel
->ExtendOpCode
= EFI_IFR_EXTEND_OP_LABEL
;
1877 mLabel
->Guid
= IfrTianoGuid
;
1880 VOID
SetNumber (IN UINT16 Number
) {
1881 mLabel
->Number
= Number
;
1885 class CIfrBanner
: public CIfrObj
, public CIfrOpHeader
{
1887 EFI_IFR_GUID_BANNER
*mBanner
;
1890 CIfrBanner () : CIfrObj (EFI_IFR_GUID_OP
, (CHAR8
**)NULL
, sizeof (EFI_IFR_GUID_BANNER
)),
1891 CIfrOpHeader (EFI_IFR_GUID_OP
, &(GetObjBinAddr
<EFI_IFR_GUID_BANNER
>())->Header
, sizeof (EFI_IFR_GUID_BANNER
)), mBanner(GetObjBinAddr
<EFI_IFR_GUID_BANNER
>()) {
1892 mBanner
->ExtendOpCode
= EFI_IFR_EXTEND_OP_BANNER
;
1893 mBanner
->Guid
= IfrTianoGuid
;
1896 VOID
SetTitle (IN EFI_STRING_ID StringId
) {
1897 mBanner
->Title
= StringId
;
1900 VOID
SetLine (IN UINT16 Line
) {
1901 mBanner
->LineNumber
= Line
;
1904 VOID
SetAlign (IN UINT8 Align
) {
1905 mBanner
->Alignment
= Align
;
1909 class CIfrOptionKey
: public CIfrObj
, public CIfrOpHeader
{
1911 EFI_IFR_GUID_OPTIONKEY
*mOptionKey
;
1915 IN EFI_QUESTION_ID QuestionId
,
1916 IN EFI_IFR_TYPE_VALUE
&OptionValue
,
1917 IN EFI_QUESTION_ID KeyValue
1918 ) : CIfrObj (EFI_IFR_GUID_OP
, (CHAR8
**)NULL
, sizeof (EFI_IFR_GUID_OPTIONKEY
)),
1919 CIfrOpHeader (EFI_IFR_GUID_OP
, &(GetObjBinAddr
<EFI_IFR_GUID_OPTIONKEY
>())->Header
, sizeof (EFI_IFR_GUID_OPTIONKEY
)), mOptionKey(GetObjBinAddr
<EFI_IFR_GUID_OPTIONKEY
>()) {
1920 mOptionKey
->ExtendOpCode
= EFI_IFR_EXTEND_OP_OPTIONKEY
;
1921 mOptionKey
->Guid
= IfrFrameworkGuid
;
1922 mOptionKey
->QuestionId
= QuestionId
;
1923 mOptionKey
->OptionValue
= OptionValue
;
1924 mOptionKey
->KeyValue
= KeyValue
;
1928 class CIfrVarEqName
: public CIfrObj
, public CIfrOpHeader
{
1930 EFI_IFR_GUID_VAREQNAME
*mVarEqName
;
1934 IN EFI_QUESTION_ID QuestionId
,
1935 IN EFI_STRING_ID NameId
1936 ) : CIfrObj (EFI_IFR_GUID_OP
, (CHAR8
**)NULL
, sizeof (EFI_IFR_GUID_VAREQNAME
)),
1937 CIfrOpHeader (EFI_IFR_GUID_OP
, &(GetObjBinAddr
<EFI_IFR_GUID_VAREQNAME
>())->Header
, sizeof (EFI_IFR_GUID_VAREQNAME
)), mVarEqName(GetObjBinAddr
<EFI_IFR_GUID_VAREQNAME
>()) {
1938 mVarEqName
->ExtendOpCode
= EFI_IFR_EXTEND_OP_VAREQNAME
;
1939 mVarEqName
->Guid
= IfrFrameworkGuid
;
1940 mVarEqName
->QuestionId
= QuestionId
;
1941 mVarEqName
->NameId
= NameId
;
1945 class CIfrTimeout
: public CIfrObj
, public CIfrOpHeader
{
1947 EFI_IFR_GUID_TIMEOUT
*mTimeout
;
1950 CIfrTimeout (IN UINT16 Timeout
= 0) : CIfrObj (EFI_IFR_GUID_OP
, (CHAR8
**)NULL
, sizeof (EFI_IFR_GUID_TIMEOUT
)),
1951 CIfrOpHeader (EFI_IFR_GUID_OP
, &(GetObjBinAddr
<EFI_IFR_GUID_TIMEOUT
>())->Header
, sizeof (EFI_IFR_GUID_TIMEOUT
)), mTimeout(GetObjBinAddr
<EFI_IFR_GUID_TIMEOUT
>()) {
1952 mTimeout
->ExtendOpCode
= EFI_IFR_EXTEND_OP_TIMEOUT
;
1953 mTimeout
->Guid
= IfrTianoGuid
;
1954 mTimeout
->TimeOut
= Timeout
;
1957 VOID
SetTimeout (IN UINT16 Timeout
) {
1958 mTimeout
->TimeOut
= Timeout
;
1962 class CIfrGuid
: public CIfrObj
, public CIfrOpHeader
{
1964 EFI_IFR_GUID
*mGuid
;
1967 CIfrGuid (UINT8 Size
) : CIfrObj (EFI_IFR_GUID_OP
, (CHAR8
**)NULL
, sizeof (EFI_IFR_GUID
)+Size
),
1968 CIfrOpHeader (EFI_IFR_GUID_OP
, &(GetObjBinAddr
<EFI_IFR_GUID
>())->Header
, sizeof (EFI_IFR_GUID
)+Size
), mGuid(GetObjBinAddr
<EFI_IFR_GUID
>()) {
1969 memset (&mGuid
->Guid
, 0, sizeof (EFI_GUID
));
1972 VOID
SetGuid (IN EFI_GUID
*Guid
) {
1973 memmove (&mGuid
->Guid
, Guid
, sizeof (EFI_GUID
));
1976 VOID
SetData (IN UINT8
* DataBuff
, IN UINT8 Size
) {
1977 memmove ((UINT8
*)mGuid
+ sizeof (EFI_IFR_GUID
), DataBuff
, Size
);
1981 class CIfrDup
: public CIfrObj
, public CIfrOpHeader
{
1985 ) : CIfrObj (EFI_IFR_DUP_OP
),
1986 CIfrOpHeader (EFI_IFR_DUP_OP
, &(GetObjBinAddr
<EFI_IFR_DUP
>())->Header
) {
1991 class CIfrEqIdId
: public CIfrObj
, public CIfrOpHeader
{
1993 EFI_IFR_EQ_ID_ID
*mEqIdId
;
1998 ) : CIfrObj (EFI_IFR_EQ_ID_ID_OP
),
1999 CIfrOpHeader (EFI_IFR_EQ_ID_ID_OP
, &(GetObjBinAddr
<EFI_IFR_EQ_ID_ID
>())->Header
), mEqIdId(GetObjBinAddr
<EFI_IFR_EQ_ID_ID
>()) {
2001 mEqIdId
->QuestionId1
= EFI_QUESTION_ID_INVALID
;
2002 mEqIdId
->QuestionId2
= EFI_QUESTION_ID_INVALID
;
2005 VOID
SetQuestionId1 (
2006 IN EFI_QUESTION_ID QuestionId
,
2010 if (QuestionId
!= EFI_QUESTION_ID_INVALID
) {
2011 mEqIdId
->QuestionId1
= QuestionId
;
2013 gCFormPkg
.AssignPending (VarIdStr
, (VOID
*)(&mEqIdId
->QuestionId1
), sizeof (EFI_QUESTION_ID
), LineNo
, NO_QST_REFED
);
2017 VOID
SetQuestionId2 (
2018 IN EFI_QUESTION_ID QuestionId
,
2022 if (QuestionId
!= EFI_QUESTION_ID_INVALID
) {
2023 mEqIdId
->QuestionId2
= QuestionId
;
2025 gCFormPkg
.AssignPending (VarIdStr
, (VOID
*)(&mEqIdId
->QuestionId2
), sizeof (EFI_QUESTION_ID
), LineNo
, NO_QST_REFED
);
2030 class CIfrEqIdVal
: public CIfrObj
, public CIfrOpHeader
{
2032 EFI_IFR_EQ_ID_VAL
*mEqIdVal
;
2037 ) : CIfrObj (EFI_IFR_EQ_ID_VAL_OP
),
2038 CIfrOpHeader (EFI_IFR_EQ_ID_VAL_OP
, &(GetObjBinAddr
<EFI_IFR_EQ_ID_VAL
>())->Header
), mEqIdVal(GetObjBinAddr
<EFI_IFR_EQ_ID_VAL
>()) {
2040 mEqIdVal
->QuestionId
= EFI_QUESTION_ID_INVALID
;
2043 VOID
SetQuestionId (
2044 IN EFI_QUESTION_ID QuestionId
,
2048 if (QuestionId
!= EFI_QUESTION_ID_INVALID
) {
2049 mEqIdVal
->QuestionId
= QuestionId
;
2051 gCFormPkg
.AssignPending (VarIdStr
, (VOID
*)(&mEqIdVal
->QuestionId
), sizeof (EFI_QUESTION_ID
), LineNo
, NO_QST_REFED
);
2055 VOID
SetValue (IN UINT16 Value
) {
2056 mEqIdVal
->Value
= Value
;
2060 class CIfrEqIdList
: public CIfrObj
, public CIfrOpHeader
{
2062 EFI_IFR_EQ_ID_VAL_LIST
*mEqIdVList
;
2067 ) : CIfrObj (EFI_IFR_EQ_ID_VAL_LIST_OP
, (CHAR8
**)NULL
, sizeof (EFI_IFR_EQ_ID_VAL_LIST
), TRUE
),
2068 CIfrOpHeader (EFI_IFR_EQ_ID_VAL_LIST_OP
, &(GetObjBinAddr
<EFI_IFR_EQ_ID_VAL_LIST
>())->Header
), mEqIdVList(GetObjBinAddr
<EFI_IFR_EQ_ID_VAL_LIST
>()) {
2070 mEqIdVList
->QuestionId
= EFI_QUESTION_ID_INVALID
;
2071 mEqIdVList
->ListLength
= 0;
2072 mEqIdVList
->ValueList
[0] = 0;
2075 VOID
UpdateIfrBuffer (
2077 _EMIT_PENDING_OBJ();
2078 mEqIdVList
= GetObjBinAddr
<EFI_IFR_EQ_ID_VAL_LIST
>();
2079 UpdateHeader (&mEqIdVList
->Header
);
2082 VOID
SetQuestionId (
2083 IN EFI_QUESTION_ID QuestionId
,
2087 if (QuestionId
!= EFI_QUESTION_ID_INVALID
) {
2088 mEqIdVList
->QuestionId
= QuestionId
;
2090 gCFormPkg
.AssignPending (VarIdStr
, (VOID
*)(&mEqIdVList
->QuestionId
), sizeof (EFI_QUESTION_ID
), LineNo
, NO_QST_REFED
);
2094 VOID
SetListLength (IN UINT16 ListLength
) {
2095 mEqIdVList
->ListLength
= ListLength
;
2098 VOID
SetValueList (IN UINT16 Index
, IN UINT16 Value
) {
2100 mEqIdVList
->ValueList
[0] = Value
;
2104 if (ExpendObjBin (sizeof (UINT16
)) ==TRUE
) {
2105 IncLength (sizeof (UINT16
));
2106 mEqIdVList
->ValueList
[Index
] = Value
;
2111 class CIfrQuestionRef1
: public CIfrObj
, public CIfrOpHeader
{
2113 EFI_IFR_QUESTION_REF1
*mQuestionRef1
;
2118 ) : CIfrObj (EFI_IFR_QUESTION_REF1_OP
),
2119 CIfrOpHeader (EFI_IFR_QUESTION_REF1_OP
, &(GetObjBinAddr
<EFI_IFR_QUESTION_REF1
>())->Header
), mQuestionRef1(GetObjBinAddr
<EFI_IFR_QUESTION_REF1
>()) {
2121 mQuestionRef1
->QuestionId
= EFI_QUESTION_ID_INVALID
;
2124 VOID
SetQuestionId (
2125 IN EFI_QUESTION_ID QuestionId
,
2129 if (QuestionId
!= EFI_QUESTION_ID_INVALID
) {
2130 mQuestionRef1
->QuestionId
= QuestionId
;
2132 gCFormPkg
.AssignPending (VarIdStr
, (VOID
*)(&mQuestionRef1
->QuestionId
), sizeof (EFI_QUESTION_ID
), LineNo
, NO_QST_REFED
);
2137 class CIfrQuestionRef2
: public CIfrObj
, public CIfrOpHeader
{
2141 ) : CIfrObj (EFI_IFR_QUESTION_REF2_OP
),
2142 CIfrOpHeader (EFI_IFR_QUESTION_REF2_OP
, &(GetObjBinAddr
<EFI_IFR_QUESTION_REF2
>())->Header
) {
2147 class CIfrQuestionRef3
: public CIfrObj
, public CIfrOpHeader
{
2151 ) : CIfrObj (EFI_IFR_QUESTION_REF3_OP
),
2152 CIfrOpHeader (EFI_IFR_QUESTION_REF3_OP
, &(GetObjBinAddr
<EFI_IFR_QUESTION_REF3
>())->Header
) {
2157 class CIfrQuestionRef3_2
: public CIfrObj
, public CIfrOpHeader
{
2159 EFI_IFR_QUESTION_REF3_2
*mQuestionRef3_2
;
2162 CIfrQuestionRef3_2 (
2164 ) : CIfrObj (EFI_IFR_QUESTION_REF3_OP
, (CHAR8
**)NULL
, sizeof (EFI_IFR_QUESTION_REF3_2
)),
2165 CIfrOpHeader (EFI_IFR_QUESTION_REF3_OP
, &(GetObjBinAddr
<EFI_IFR_QUESTION_REF3_2
>())->Header
, sizeof (EFI_IFR_QUESTION_REF3_2
)), mQuestionRef3_2(GetObjBinAddr
<EFI_IFR_QUESTION_REF3_2
>()) {
2167 mQuestionRef3_2
->DevicePath
= EFI_STRING_ID_INVALID
;
2170 VOID
SetDevicePath (IN EFI_STRING_ID DevicePath
) {
2171 mQuestionRef3_2
->DevicePath
= DevicePath
;
2175 class CIfrQuestionRef3_3
: public CIfrObj
, public CIfrOpHeader
{
2177 EFI_IFR_QUESTION_REF3_3
*mQuestionRef3_3
;
2180 CIfrQuestionRef3_3 (
2182 ) : CIfrObj (EFI_IFR_QUESTION_REF3_OP
, (CHAR8
**)NULL
, sizeof (EFI_IFR_QUESTION_REF3_3
)),
2183 CIfrOpHeader (EFI_IFR_QUESTION_REF3_OP
, &(GetObjBinAddr
<EFI_IFR_QUESTION_REF3_3
>())->Header
, sizeof (EFI_IFR_QUESTION_REF3_3
)), mQuestionRef3_3(GetObjBinAddr
<EFI_IFR_QUESTION_REF3_3
>()) {
2185 mQuestionRef3_3
->DevicePath
= EFI_STRING_ID_INVALID
;
2186 memset (&mQuestionRef3_3
->Guid
, 0, sizeof (EFI_GUID
));
2189 VOID
SetDevicePath (IN EFI_STRING_ID DevicePath
) {
2190 mQuestionRef3_3
->DevicePath
= DevicePath
;
2193 VOID
SetGuid (IN EFI_GUID
*Guid
) {
2194 mQuestionRef3_3
->Guid
= *Guid
;
2198 class CIfrRuleRef
: public CIfrObj
, public CIfrOpHeader
{
2200 EFI_IFR_RULE_REF
*mRuleRef
;
2205 ) : CIfrObj (EFI_IFR_RULE_REF_OP
),
2206 CIfrOpHeader (EFI_IFR_RULE_REF_OP
, &(GetObjBinAddr
<EFI_IFR_RULE_REF
>())->Header
), mRuleRef(GetObjBinAddr
<EFI_IFR_RULE_REF
>()) {
2208 mRuleRef
->RuleId
= EFI_RULE_ID_INVALID
;
2211 VOID
SetRuleId (IN UINT8 RuleId
) {
2212 mRuleRef
->RuleId
= RuleId
;
2216 class CIfrStringRef1
: public CIfrObj
, public CIfrOpHeader
{
2218 EFI_IFR_STRING_REF1
*mStringRef1
;
2223 ) : CIfrObj (EFI_IFR_STRING_REF1_OP
),
2224 CIfrOpHeader (EFI_IFR_STRING_REF1_OP
, &(GetObjBinAddr
<EFI_IFR_STRING_REF1
>())->Header
), mStringRef1(GetObjBinAddr
<EFI_IFR_STRING_REF1
>()) {
2226 mStringRef1
->StringId
= EFI_STRING_ID_INVALID
;
2229 VOID
SetStringId (IN EFI_STRING_ID StringId
) {
2230 mStringRef1
->StringId
= StringId
;
2234 class CIfrStringRef2
: public CIfrObj
, public CIfrOpHeader
{
2238 ) : CIfrObj (EFI_IFR_STRING_REF2_OP
),
2239 CIfrOpHeader (EFI_IFR_STRING_REF2_OP
, &(GetObjBinAddr
<EFI_IFR_STRING_REF2
>())->Header
) {
2244 class CIfrThis
: public CIfrObj
, public CIfrOpHeader
{
2248 ) : CIfrObj (EFI_IFR_THIS_OP
),
2249 CIfrOpHeader (EFI_IFR_THIS_OP
, &(GetObjBinAddr
<EFI_IFR_THIS
>())->Header
) {
2254 class CIfrSecurity
: public CIfrObj
, public CIfrOpHeader
{
2256 EFI_IFR_SECURITY
*mSecurity
;
2261 ) : CIfrObj (EFI_IFR_SECURITY_OP
),
2262 CIfrOpHeader (EFI_IFR_SECURITY_OP
, &(GetObjBinAddr
<EFI_IFR_SECURITY
>())->Header
), mSecurity(GetObjBinAddr
<EFI_IFR_SECURITY
>()) {
2264 memset (&mSecurity
->Permissions
, 0, sizeof (EFI_GUID
));
2267 VOID
SetPermissions (IN EFI_GUID
*Permissions
) {
2268 memmove (&mSecurity
->Permissions
, Permissions
, sizeof (EFI_GUID
));
2272 class CIfrUint8
: public CIfrObj
, public CIfrOpHeader
{
2274 EFI_IFR_UINT8
*mUint8
;
2279 ) : CIfrObj (EFI_IFR_UINT8_OP
),
2280 CIfrOpHeader (EFI_IFR_UINT8_OP
, &(GetObjBinAddr
<EFI_IFR_UINT8
>())->Header
), mUint8(GetObjBinAddr
<EFI_IFR_UINT8
>()) {
2284 VOID
SetValue (IN UINT8 Value
) {
2285 mUint8
->Value
= Value
;
2289 class CIfrUint16
: public CIfrObj
, public CIfrOpHeader
{
2291 EFI_IFR_UINT16
*mUint16
;
2296 ) : CIfrObj (EFI_IFR_UINT16_OP
),
2297 CIfrOpHeader (EFI_IFR_UINT16_OP
, &(GetObjBinAddr
<EFI_IFR_UINT16
>())->Header
), mUint16(GetObjBinAddr
<EFI_IFR_UINT16
>()) {
2301 VOID
SetValue (IN UINT16 Value
) {
2302 mUint16
->Value
= Value
;
2306 class CIfrUint32
: public CIfrObj
, public CIfrOpHeader
{
2308 EFI_IFR_UINT32
*mUint32
;
2313 ) : CIfrObj (EFI_IFR_UINT32_OP
),
2314 CIfrOpHeader (EFI_IFR_UINT32_OP
, &(GetObjBinAddr
<EFI_IFR_UINT32
>())->Header
), mUint32(GetObjBinAddr
<EFI_IFR_UINT32
>()) {
2318 VOID
SetValue (IN UINT32 Value
) {
2319 mUint32
->Value
= Value
;
2323 class CIfrUint64
: public CIfrObj
, public CIfrOpHeader
{
2325 EFI_IFR_UINT64
*mUint64
;
2330 ) : CIfrObj (EFI_IFR_UINT64_OP
),
2331 CIfrOpHeader (EFI_IFR_UINT64_OP
, &(GetObjBinAddr
<EFI_IFR_UINT64
>())->Header
), mUint64(GetObjBinAddr
<EFI_IFR_UINT64
>()) {
2335 VOID
SetValue (IN UINT64 Value
) {
2336 mUint64
->Value
= Value
;
2340 class CIfrTrue
: public CIfrObj
, public CIfrOpHeader
{
2344 ) : CIfrObj (EFI_IFR_TRUE_OP
),
2345 CIfrOpHeader (EFI_IFR_TRUE_OP
, &(GetObjBinAddr
<EFI_IFR_TRUE
>())->Header
) {
2350 class CIfrFalse
: public CIfrObj
, public CIfrOpHeader
{
2354 ) : CIfrObj (EFI_IFR_FALSE_OP
),
2355 CIfrOpHeader (EFI_IFR_FALSE_OP
, &(GetObjBinAddr
<EFI_IFR_FALSE
>())->Header
) {
2360 class CIfrOne
: public CIfrObj
, public CIfrOpHeader
{
2364 ) : CIfrObj (EFI_IFR_ONE_OP
),
2365 CIfrOpHeader (EFI_IFR_ONE_OP
, &(GetObjBinAddr
<EFI_IFR_ONE
>())->Header
) {
2370 class CIfrOnes
: public CIfrObj
, public CIfrOpHeader
{
2374 ) : CIfrObj (EFI_IFR_ONES_OP
),
2375 CIfrOpHeader (EFI_IFR_ONES_OP
, &(GetObjBinAddr
<EFI_IFR_ONES
>())->Header
) {
2380 class CIfrZero
: public CIfrObj
, public CIfrOpHeader
{
2384 ) : CIfrObj (EFI_IFR_ZERO_OP
),
2385 CIfrOpHeader (EFI_IFR_ZERO_OP
, &(GetObjBinAddr
<EFI_IFR_ZERO
>())->Header
) {
2390 class CIfrUndefined
: public CIfrObj
, public CIfrOpHeader
{
2394 ) : CIfrObj (EFI_IFR_UNDEFINED_OP
),
2395 CIfrOpHeader (EFI_IFR_UNDEFINED_OP
, &(GetObjBinAddr
<EFI_IFR_UNDEFINED
>())->Header
) {
2400 class CIfrVersion
: public CIfrObj
, public CIfrOpHeader
{
2404 ) : CIfrObj (EFI_IFR_VERSION_OP
),
2405 CIfrOpHeader (EFI_IFR_VERSION_OP
, &(GetObjBinAddr
<EFI_IFR_VERSION
>())->Header
) {
2410 class CIfrLength
: public CIfrObj
, public CIfrOpHeader
{
2414 ) : CIfrObj (EFI_IFR_LENGTH_OP
),
2415 CIfrOpHeader (EFI_IFR_LENGTH_OP
, &(GetObjBinAddr
<EFI_IFR_LENGTH
>())->Header
) {
2420 class CIfrNot
: public CIfrObj
, public CIfrOpHeader
{
2424 ) : CIfrObj (EFI_IFR_NOT_OP
),
2425 CIfrOpHeader (EFI_IFR_NOT_OP
, &(GetObjBinAddr
<EFI_IFR_NOT
>())->Header
) {
2430 class CIfrBitWiseNot
: public CIfrObj
, public CIfrOpHeader
{
2434 ) : CIfrObj (EFI_IFR_BITWISE_NOT_OP
),
2435 CIfrOpHeader (EFI_IFR_BITWISE_NOT_OP
, &(GetObjBinAddr
<EFI_IFR_BITWISE_NOT
>())->Header
) {
2440 class CIfrToBoolean
: public CIfrObj
, public CIfrOpHeader
{
2444 ) : CIfrObj (EFI_IFR_TO_BOOLEAN_OP
),
2445 CIfrOpHeader (EFI_IFR_TO_BOOLEAN_OP
, &(GetObjBinAddr
<EFI_IFR_TO_BOOLEAN
>())->Header
) {
2450 class CIfrToString
: public CIfrObj
, public CIfrOpHeader
{
2452 EFI_IFR_TO_STRING
*mToString
;
2457 ) : CIfrObj (EFI_IFR_TO_STRING_OP
),
2458 CIfrOpHeader (EFI_IFR_TO_STRING_OP
, &(GetObjBinAddr
<EFI_IFR_TO_STRING
>())->Header
), mToString(GetObjBinAddr
<EFI_IFR_TO_STRING
>()) {
2462 VOID
SetFormat (IN UINT8 Format
) {
2463 mToString
->Format
= Format
;
2467 class CIfrToUint
: public CIfrObj
, public CIfrOpHeader
{
2471 ) : CIfrObj (EFI_IFR_TO_UINT_OP
),
2472 CIfrOpHeader (EFI_IFR_TO_UINT_OP
, &(GetObjBinAddr
<EFI_IFR_TO_UINT
>())->Header
) {
2477 class CIfrToUpper
: public CIfrObj
, public CIfrOpHeader
{
2481 ) : CIfrObj (EFI_IFR_TO_UPPER_OP
),
2482 CIfrOpHeader (EFI_IFR_TO_UPPER_OP
, &(GetObjBinAddr
<EFI_IFR_TO_UPPER
>())->Header
) {
2487 class CIfrToLower
: public CIfrObj
, public CIfrOpHeader
{
2491 ) : CIfrObj (EFI_IFR_TO_LOWER_OP
),
2492 CIfrOpHeader (EFI_IFR_TO_LOWER_OP
, &(GetObjBinAddr
<EFI_IFR_TO_LOWER
>())->Header
) {
2497 class CIfrAdd
: public CIfrObj
, public CIfrOpHeader
{
2501 ) : CIfrObj (EFI_IFR_ADD_OP
),
2502 CIfrOpHeader (EFI_IFR_ADD_OP
, &(GetObjBinAddr
<EFI_IFR_ADD
>())->Header
) {
2507 class CIfrBitWiseAnd
: public CIfrObj
, public CIfrOpHeader
{
2511 ) : CIfrObj (EFI_IFR_BITWISE_AND_OP
),
2512 CIfrOpHeader (EFI_IFR_BITWISE_AND_OP
, &(GetObjBinAddr
<EFI_IFR_BITWISE_AND
>())->Header
) {
2517 class CIfrBitWiseOr
: public CIfrObj
, public CIfrOpHeader
{
2521 ) : CIfrObj (EFI_IFR_BITWISE_OR_OP
),
2522 CIfrOpHeader (EFI_IFR_BITWISE_OR_OP
, &(GetObjBinAddr
<EFI_IFR_BITWISE_OR
>())->Header
) {
2527 class CIfrAnd
: public CIfrObj
, public CIfrOpHeader
{
2531 ) : CIfrObj (EFI_IFR_AND_OP
),
2532 CIfrOpHeader (EFI_IFR_AND_OP
, &(GetObjBinAddr
<EFI_IFR_AND
>())->Header
) {
2537 class CIfrCatenate
: public CIfrObj
, public CIfrOpHeader
{
2541 ) : CIfrObj (EFI_IFR_CATENATE_OP
),
2542 CIfrOpHeader (EFI_IFR_CATENATE_OP
, &(GetObjBinAddr
<EFI_IFR_CATENATE
>())->Header
) {
2547 class CIfrDivide
: public CIfrObj
, public CIfrOpHeader
{
2551 ) : CIfrObj (EFI_IFR_DIVIDE_OP
),
2552 CIfrOpHeader (EFI_IFR_DIVIDE_OP
, &(GetObjBinAddr
<EFI_IFR_DIVIDE
>())->Header
) {
2557 class CIfrEqual
: public CIfrObj
, public CIfrOpHeader
{
2561 ) : CIfrObj (EFI_IFR_EQUAL_OP
),
2562 CIfrOpHeader (EFI_IFR_EQUAL_OP
, &(GetObjBinAddr
<EFI_IFR_EQUAL
>())->Header
) {
2567 class CIfrGreaterEqual
: public CIfrObj
, public CIfrOpHeader
{
2571 ) : CIfrObj (EFI_IFR_GREATER_EQUAL_OP
),
2572 CIfrOpHeader (EFI_IFR_GREATER_EQUAL_OP
, &(GetObjBinAddr
<EFI_IFR_GREATER_EQUAL
>())->Header
) {
2577 class CIfrGreaterThan
: public CIfrObj
, public CIfrOpHeader
{
2581 ) : CIfrObj (EFI_IFR_GREATER_THAN_OP
),
2582 CIfrOpHeader (EFI_IFR_GREATER_THAN_OP
, &(GetObjBinAddr
<EFI_IFR_GREATER_THAN
>())->Header
) {
2587 class CIfrLessEqual
: public CIfrObj
, public CIfrOpHeader
{
2591 ) : CIfrObj (EFI_IFR_LESS_EQUAL_OP
),
2592 CIfrOpHeader (EFI_IFR_LESS_EQUAL_OP
, &(GetObjBinAddr
<EFI_IFR_LESS_EQUAL
>())->Header
) {
2597 class CIfrLessThan
: public CIfrObj
, public CIfrOpHeader
{
2601 ) : CIfrObj (EFI_IFR_LESS_THAN_OP
),
2602 CIfrOpHeader (EFI_IFR_LESS_THAN_OP
, &(GetObjBinAddr
<EFI_IFR_LESS_THAN
>())->Header
) {
2607 class CIfrMap
: public CIfrObj
, public CIfrOpHeader
{
2611 ) : CIfrObj (EFI_IFR_MAP_OP
),
2612 CIfrOpHeader (EFI_IFR_MAP_OP
, &(GetObjBinAddr
<EFI_IFR_MAP
>())->Header
) {
2617 class CIfrMatch
: public CIfrObj
, public CIfrOpHeader
{
2621 ) : CIfrObj (EFI_IFR_MATCH_OP
),
2622 CIfrOpHeader (EFI_IFR_MATCH_OP
, &(GetObjBinAddr
<EFI_IFR_MATCH
>())->Header
) {
2627 class CIfrMatch2
: public CIfrObj
, public CIfrOpHeader
{
2629 EFI_IFR_MATCH2
*mMatch2
;
2635 ) : CIfrObj (EFI_IFR_MATCH2_OP
),
2636 CIfrOpHeader (EFI_IFR_MATCH2_OP
, &(GetObjBinAddr
<EFI_IFR_MATCH2
>())->Header
), mMatch2(GetObjBinAddr
<EFI_IFR_MATCH2
>()) {
2638 memmove (&mMatch2
->SyntaxType
, Guid
, sizeof (EFI_GUID
));
2642 class CIfrMultiply
: public CIfrObj
, public CIfrOpHeader
{
2646 ) : CIfrObj (EFI_IFR_MULTIPLY_OP
),
2647 CIfrOpHeader (EFI_IFR_MULTIPLY_OP
, &(GetObjBinAddr
<EFI_IFR_MULTIPLY
>())->Header
) {
2652 class CIfrModulo
: public CIfrObj
, public CIfrOpHeader
{
2656 ) : CIfrObj (EFI_IFR_MODULO_OP
),
2657 CIfrOpHeader (EFI_IFR_MODULO_OP
, &(GetObjBinAddr
<EFI_IFR_MODULO
>())->Header
) {
2662 class CIfrNotEqual
: public CIfrObj
, public CIfrOpHeader
{
2666 ) : CIfrObj (EFI_IFR_NOT_EQUAL_OP
),
2667 CIfrOpHeader (EFI_IFR_NOT_EQUAL_OP
, &(GetObjBinAddr
<EFI_IFR_NOT_EQUAL
>())->Header
) {
2672 class CIfrOr
: public CIfrObj
, public CIfrOpHeader
{
2676 ) : CIfrObj (EFI_IFR_OR_OP
),
2677 CIfrOpHeader (EFI_IFR_OR_OP
, &(GetObjBinAddr
<EFI_IFR_OR
>())->Header
) {
2682 class CIfrShiftLeft
: public CIfrObj
, public CIfrOpHeader
{
2686 ) : CIfrObj (EFI_IFR_SHIFT_LEFT_OP
),
2687 CIfrOpHeader (EFI_IFR_SHIFT_LEFT_OP
, &(GetObjBinAddr
<EFI_IFR_SHIFT_LEFT
>())->Header
) {
2692 class CIfrShiftRight
: public CIfrObj
, public CIfrOpHeader
{
2696 ) : CIfrObj (EFI_IFR_SHIFT_RIGHT_OP
),
2697 CIfrOpHeader (EFI_IFR_SHIFT_RIGHT_OP
, &(GetObjBinAddr
<EFI_IFR_SHIFT_RIGHT
>())->Header
) {
2702 class CIfrSubtract
: public CIfrObj
, public CIfrOpHeader
{
2706 ) : CIfrObj (EFI_IFR_SUBTRACT_OP
),
2707 CIfrOpHeader (EFI_IFR_SUBTRACT_OP
, &(GetObjBinAddr
<EFI_IFR_SUBTRACT
>())->Header
) {
2712 class CIfrConditional
: public CIfrObj
, public CIfrOpHeader
{
2716 ) : CIfrObj (EFI_IFR_CONDITIONAL_OP
),
2717 CIfrOpHeader (EFI_IFR_CONDITIONAL_OP
, &(GetObjBinAddr
<EFI_IFR_CONDITIONAL
>())->Header
) {
2722 class CIfrFind
: public CIfrObj
, public CIfrOpHeader
{
2724 EFI_IFR_FIND
*mFind
;
2729 ) : CIfrObj (EFI_IFR_FIND_OP
),
2730 CIfrOpHeader (EFI_IFR_FIND_OP
, &(GetObjBinAddr
<EFI_IFR_FIND
>())->Header
), mFind(GetObjBinAddr
<EFI_IFR_FIND
>()) {
2734 VOID
SetFormat (IN UINT8 Format
) {
2735 mFind
->Format
= Format
;
2739 class CIfrMid
: public CIfrObj
, public CIfrOpHeader
{
2743 ) : CIfrObj (EFI_IFR_MID_OP
),
2744 CIfrOpHeader (EFI_IFR_MID_OP
, &(GetObjBinAddr
<EFI_IFR_MID
>())->Header
) {
2749 class CIfrToken
: public CIfrObj
, public CIfrOpHeader
{
2753 ) : CIfrObj (EFI_IFR_TOKEN_OP
),
2754 CIfrOpHeader (EFI_IFR_TOKEN_OP
, &(GetObjBinAddr
<EFI_IFR_TOKEN
>())->Header
) {
2759 class CIfrSpan
: public CIfrObj
, public CIfrOpHeader
{
2761 EFI_IFR_SPAN
*mSpan
;
2766 ) : CIfrObj (EFI_IFR_SPAN_OP
),
2767 CIfrOpHeader (EFI_IFR_SPAN_OP
, &(GetObjBinAddr
<EFI_IFR_SPAN
>())->Header
), mSpan(GetObjBinAddr
<EFI_IFR_SPAN
>()) {
2769 mSpan
->Flags
= EFI_IFR_FLAGS_FIRST_MATCHING
;
2772 EFI_VFR_RETURN_CODE
SetFlags (IN UINT8 LFlags
) {
2773 if (_IS_EQUAL (LFlags
, EFI_IFR_FLAGS_FIRST_MATCHING
)) {
2774 mSpan
->Flags
|= EFI_IFR_FLAGS_FIRST_MATCHING
;
2775 } else if (_FLAG_TEST_AND_CLEAR (LFlags
, EFI_IFR_FLAGS_FIRST_NON_MATCHING
)) {
2776 mSpan
->Flags
|= EFI_IFR_FLAGS_FIRST_NON_MATCHING
;
2779 return _FLAGS_ZERO (LFlags
) ? VFR_RETURN_SUCCESS
: VFR_RETURN_FLAGS_UNSUPPORTED
;