3 The definition of CFormPkg's member function
5 Copyright (c) 2004 - 2014, 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
);
96 struct SBufferNode
*mNext
;
100 BOOLEAN CompatibleMode
;
101 EFI_GUID
*OverrideClassGuid
;
102 } INPUT_INFO_TO_SYNTAX
;
107 SBufferNode
*mBufferNodeQueueHead
;
108 SBufferNode
*mBufferNodeQueueTail
;
109 SBufferNode
*mCurrBufferNode
;
111 SBufferNode
*mReadBufferNode
;
112 UINT32 mReadBufferOffset
;
116 VOID
_WRITE_PKG_LINE (IN
FILE *, IN UINT32
, IN CONST CHAR8
*, IN CHAR8
*, IN UINT32
);
117 VOID
_WRITE_PKG_END (IN
FILE *, IN UINT32
, IN CONST CHAR8
*, IN CHAR8
*, IN UINT32
);
118 SBufferNode
* GetBinBufferNodeForAddr (IN CHAR8
*);
119 SBufferNode
* CreateNewNode ();
120 SBufferNode
* GetNodeBefore (IN SBufferNode
*);
121 EFI_VFR_RETURN_CODE
InsertNodeBefore (IN SBufferNode
*, IN SBufferNode
*);
124 SPendingAssign
*PendingAssignList
;
127 CFormPkg (IN UINT32 BufferSize
= 4096);
130 CHAR8
* IfrBinBufferGet (IN UINT32
);
131 inline UINT32
GetPkgLength (VOID
);
134 UINT32
Read (IN CHAR8
*, IN UINT32
);
137 EFI_VFR_RETURN_CODE
BuildPkgHdr (OUT EFI_HII_PACKAGE_HEADER
**);
138 EFI_VFR_RETURN_CODE
BuildPkg (IN
FILE *, IN PACKAGE_DATA
*PkgData
= NULL
);
139 EFI_VFR_RETURN_CODE
BuildPkg (OUT PACKAGE_DATA
&);
140 EFI_VFR_RETURN_CODE
GenCFile (IN CHAR8
*, IN
FILE *, IN PACKAGE_DATA
*PkgData
= NULL
);
143 EFI_VFR_RETURN_CODE
AssignPending (IN CHAR8
*, IN VOID
*, IN UINT32
, IN UINT32
, IN CONST CHAR8
*Msg
= NULL
);
144 VOID
DoPendingAssign (IN CHAR8
*, IN VOID
*, IN UINT32
);
145 bool HavePendingUnassigned (VOID
);
146 VOID
PendingAssignPrintAll (VOID
);
147 EFI_VFR_RETURN_CODE
DeclarePendingQuestion (
148 IN CVfrVarDataTypeDB
&lCVfrVarDataTypeDB
,
149 IN CVfrDataStorage
&lCVfrDataStorage
,
150 IN CVfrQuestionDB
&lCVfrQuestionDB
,
151 IN EFI_GUID
*LocalFormSetGuid
,
153 OUT CHAR8
**InsertOpcodeAddr
155 EFI_VFR_RETURN_CODE
AdjustDynamicInsertOpcode (
156 IN CHAR8
*LastFormEndAddr
,
157 IN CHAR8
*InsertOpcodeAddr
159 CHAR8
* GetBufAddrBaseOnOffset (
164 extern CFormPkg gCFormPkg
;
165 extern CVfrStringDB gCVfrStringDB
;
166 extern UINT32 gAdjustOpcodeOffset
;
167 extern BOOLEAN gNeedAdjustOpcode
;
180 #define EFI_IFR_RECORDINFO_IDX_INVALUD 0xFFFFFF
181 #define EFI_IFR_RECORDINFO_IDX_START 0x0
183 class CIfrRecordInfoDB
{
187 SIfrRecord
*mIfrRecordListHead
;
188 SIfrRecord
*mIfrRecordListTail
;
190 SIfrRecord
* GetRecordInfoFromIdx (IN UINT32
);
191 BOOLEAN
CheckQuestionOpCode (IN UINT8
);
192 BOOLEAN
CheckIdOpCode (IN UINT8
);
193 EFI_QUESTION_ID
GetOpcodeQuestionId (IN EFI_IFR_OP_HEADER
*);
195 CIfrRecordInfoDB (VOID
);
196 ~CIfrRecordInfoDB (VOID
);
198 inline VOID
TurnOn (VOID
) {
202 inline VOID
TurnOff (VOID
) {
206 SIfrRecord
* GetRecordInfoFromOffset (IN UINT32
);
207 VOID
IfrAdjustOffsetForRecord (VOID
);
208 BOOLEAN
IfrAdjustDynamicOpcodeInRecords (VOID
);
210 UINT32
IfrRecordRegister (IN UINT32
, IN CHAR8
*, IN UINT8
, IN UINT32
);
211 VOID
IfrRecordInfoUpdate (IN UINT32
, IN UINT32
, IN CHAR8
*, IN UINT8
, IN UINT32
);
212 VOID
IfrRecordOutput (IN
FILE *, IN UINT32 LineNo
);
213 VOID
IfrRecordOutput (OUT PACKAGE_DATA
&);
214 EFI_VFR_RETURN_CODE
IfrRecordAdjust (VOID
);
217 extern CIfrRecordInfoDB gCIfrRecordInfoDB
;
220 * The definition of CIfrObj
222 extern BOOLEAN gCreateOp
;
235 CIfrObj (IN UINT8 OpCode
, OUT CHAR8
**IfrObj
= NULL
, IN UINT8 ObjBinLen
= 0, IN BOOLEAN DelayEmit
= FALSE
);
236 virtual ~CIfrObj(VOID
);
238 VOID
_EMIT_PENDING_OBJ (VOID
);
240 inline VOID
SetLineNo (IN UINT32 LineNo
) {
244 inline CHAR8
* GetObjBinAddr (VOID
) {
248 inline UINT32
GetObjBinOffset (VOID
) {
252 inline UINT8
GetObjBinLen (VOID
) {
256 inline bool ExpendObjBin (IN UINT8 Size
) {
257 if ((mDelayEmit
== TRUE
) && ((mObjBinLen
+ Size
) > mObjBinLen
)) {
258 mObjBinLen
= mObjBinLen
+ Size
;
265 inline bool ShrinkObjBin (IN UINT8 Size
) {
266 if ((mDelayEmit
== TRUE
) && (mObjBinLen
> Size
)) {
276 * The definition of CIfrOpHeader
280 EFI_IFR_OP_HEADER
*mHeader
;
283 CIfrOpHeader (IN UINT8 OpCode
, IN VOID
*StartAddr
, IN UINT8 Length
= 0);
284 CIfrOpHeader (IN CIfrOpHeader
&);
286 VOID
IncLength (UINT8 Size
) {
287 if ((mHeader
->Length
+ Size
) > mHeader
->Length
) {
288 mHeader
->Length
= mHeader
->Length
+ Size
;
292 VOID
DecLength (UINT8 Size
) {
293 if (mHeader
->Length
>= Size
) {
294 mHeader
->Length
-= Size
;
299 return mHeader
->Length
;
303 return mHeader
->Scope
;
306 VOID
SetScope (IN UINT8 Scope
) {
307 mHeader
->Scope
= Scope
;
310 VOID
UpdateHeader (IN EFI_IFR_OP_HEADER
*Header
) {
315 extern UINT8 gScopeCount
;
318 * The definition of CIfrStatementHeader
320 class CIfrStatementHeader
{
322 EFI_IFR_STATEMENT_HEADER
*mHeader
;
325 CIfrStatementHeader (
326 IN EFI_IFR_STATEMENT_HEADER
*StartAddr
327 ) : mHeader ((EFI_IFR_STATEMENT_HEADER
*)StartAddr
) {
329 mHeader
->Help
= EFI_STRING_ID_INVALID
;
330 mHeader
->Prompt
= EFI_STRING_ID_INVALID
;
333 EFI_IFR_STATEMENT_HEADER
*GetStatementHeader () {
337 VOID
SetPrompt (IN EFI_STRING_ID Prompt
) {
338 mHeader
->Prompt
= Prompt
;
341 VOID
SetHelp (IN EFI_STRING_ID Help
) {
342 mHeader
->Help
= Help
;
347 * The definition of CIfrQuestionHeader
349 #define EFI_IFR_QUESTION_FLAG_DEFAULT 0
351 class CIfrQuestionHeader
: public CIfrStatementHeader
{
353 EFI_IFR_QUESTION_HEADER
*mHeader
;
355 EFI_IFR_STATEMENT_HEADER
* QH2SH (EFI_IFR_QUESTION_HEADER
*Qheader
) {
356 return &(Qheader
)->Header
;
360 EFI_QUESTION_ID
QUESTION_ID (VOID
) {
361 return mHeader
->QuestionId
;
364 EFI_VARSTORE_ID
VARSTORE_ID (VOID
) {
365 return mHeader
->VarStoreId
;
368 VOID
VARSTORE_INFO (OUT EFI_VARSTORE_INFO
*Info
) {
370 Info
->mVarStoreId
= mHeader
->VarStoreId
;
371 memmove (&Info
->mVarStoreId
, &mHeader
->VarStoreInfo
, sizeof (Info
->mVarStoreId
));
376 return mHeader
->Flags
;
381 IN EFI_IFR_QUESTION_HEADER
*StartAddr
,
382 IN UINT8 Flags
= EFI_IFR_QUESTION_FLAG_DEFAULT
383 ) : CIfrStatementHeader (QH2SH(StartAddr
)) {
385 mHeader
->QuestionId
= EFI_QUESTION_ID_INVALID
;
386 mHeader
->VarStoreId
= EFI_VARSTORE_ID_INVALID
;
387 mHeader
->VarStoreInfo
.VarName
= EFI_STRING_ID_INVALID
;
388 mHeader
->VarStoreInfo
.VarOffset
= EFI_VAROFFSET_INVALID
;
389 mHeader
->Flags
= Flags
;
392 VOID
SetQuestionId (IN EFI_QUESTION_ID QuestionId
) {
393 mHeader
->QuestionId
= QuestionId
;
396 VOID
SetVarStoreInfo (IN EFI_VARSTORE_INFO
*Info
) {
397 mHeader
->VarStoreId
= Info
->mVarStoreId
;
398 mHeader
->VarStoreInfo
.VarName
= Info
->mInfo
.mVarName
;
399 mHeader
->VarStoreInfo
.VarOffset
= Info
->mInfo
.mVarOffset
;
402 EFI_VFR_RETURN_CODE
SetFlags (IN UINT8 Flags
) {
403 if (_FLAG_TEST_AND_CLEAR (Flags
, EFI_IFR_FLAG_READ_ONLY
)) {
404 mHeader
->Flags
|= EFI_IFR_FLAG_READ_ONLY
;
407 _FLAG_CLEAR (Flags
, 0x02);
409 if (_FLAG_TEST_AND_CLEAR (Flags
, EFI_IFR_FLAG_CALLBACK
)) {
410 mHeader
->Flags
|= EFI_IFR_FLAG_CALLBACK
;
414 // ignore NVAccessFlag
416 _FLAG_CLEAR (Flags
, 0x08);
418 if (_FLAG_TEST_AND_CLEAR (Flags
, EFI_IFR_FLAG_RESET_REQUIRED
)) {
419 mHeader
->Flags
|= EFI_IFR_FLAG_RESET_REQUIRED
;
423 // Set LateCheck Flag to compatible for framework flag
424 // but it uses 0x20 as its flag, if in the future UEFI may take this flag
426 if (_FLAG_TEST_AND_CLEAR (Flags
, 0x20)) {
427 mHeader
->Flags
|= 0x20;
430 if (_FLAG_TEST_AND_CLEAR (Flags
, EFI_IFR_FLAG_OPTIONS_ONLY
)) {
431 mHeader
->Flags
|= EFI_IFR_FLAG_OPTIONS_ONLY
;
434 return _FLAGS_ZERO (Flags
) ? VFR_RETURN_SUCCESS
: VFR_RETURN_FLAGS_UNSUPPORTED
;
437 VOID
UpdateCIfrQuestionHeader (IN EFI_IFR_QUESTION_HEADER
*Header
) {
443 * The definition of CIfrMinMaxStepData
445 class CIfrMinMaxStepData
{
447 MINMAXSTEP_DATA
*mMinMaxStepData
;
452 CIfrMinMaxStepData (MINMAXSTEP_DATA
*DataAddr
, BOOLEAN NumericOpcode
=FALSE
) : mMinMaxStepData (DataAddr
) {
453 mMinMaxStepData
->u64
.MinValue
= 0;
454 mMinMaxStepData
->u64
.MaxValue
= 0;
455 mMinMaxStepData
->u64
.Step
= 0;
457 IsNumeric
= NumericOpcode
;
460 VOID
SetMinMaxStepData (IN UINT64 MinValue
, IN UINT64 MaxValue
, IN UINT64 Step
) {
462 mMinMaxStepData
->u64
.MinValue
= MinValue
;
463 mMinMaxStepData
->u64
.MaxValue
= MaxValue
;
466 if (MinValue
< mMinMaxStepData
->u64
.MinValue
) {
467 mMinMaxStepData
->u64
.MinValue
= MinValue
;
469 if (MaxValue
> mMinMaxStepData
->u64
.MaxValue
) {
470 mMinMaxStepData
->u64
.MaxValue
= MaxValue
;
473 mMinMaxStepData
->u64
.Step
= Step
;
476 VOID
SetMinMaxStepData (IN UINT32 MinValue
, IN UINT32 MaxValue
, IN UINT32 Step
) {
478 mMinMaxStepData
->u32
.MinValue
= MinValue
;
479 mMinMaxStepData
->u32
.MaxValue
= MaxValue
;
482 if (MinValue
< mMinMaxStepData
->u32
.MinValue
) {
483 mMinMaxStepData
->u32
.MinValue
= MinValue
;
485 if (MaxValue
> mMinMaxStepData
->u32
.MaxValue
) {
486 mMinMaxStepData
->u32
.MaxValue
= MaxValue
;
489 mMinMaxStepData
->u32
.Step
= Step
;
492 VOID
SetMinMaxStepData (IN UINT16 MinValue
, IN UINT16 MaxValue
, IN UINT16 Step
) {
494 mMinMaxStepData
->u16
.MinValue
= MinValue
;
495 mMinMaxStepData
->u16
.MaxValue
= MaxValue
;
498 if (MinValue
< mMinMaxStepData
->u16
.MinValue
) {
499 mMinMaxStepData
->u16
.MinValue
= MinValue
;
501 if (MaxValue
> mMinMaxStepData
->u16
.MaxValue
) {
502 mMinMaxStepData
->u16
.MaxValue
= MaxValue
;
505 mMinMaxStepData
->u16
.Step
= Step
;
508 VOID
SetMinMaxStepData (IN UINT8 MinValue
, IN UINT8 MaxValue
, IN UINT8 Step
) {
510 mMinMaxStepData
->u8
.MinValue
= MinValue
;
511 mMinMaxStepData
->u8
.MaxValue
= MaxValue
;
514 if (MinValue
< mMinMaxStepData
->u8
.MinValue
) {
515 mMinMaxStepData
->u8
.MinValue
= MinValue
;
517 if (MaxValue
> mMinMaxStepData
->u8
.MaxValue
) {
518 mMinMaxStepData
->u8
.MaxValue
= MaxValue
;
521 mMinMaxStepData
->u8
.Step
= Step
;
524 UINT64
GetMinData (UINT8 VarType
) {
527 case EFI_IFR_TYPE_NUM_SIZE_64
:
528 MinValue
= mMinMaxStepData
->u64
.MinValue
;
530 case EFI_IFR_TYPE_NUM_SIZE_32
:
531 MinValue
= (UINT64
) mMinMaxStepData
->u32
.MinValue
;
533 case EFI_IFR_TYPE_NUM_SIZE_16
:
534 MinValue
= (UINT64
) mMinMaxStepData
->u16
.MinValue
;
536 case EFI_IFR_TYPE_NUM_SIZE_8
:
537 MinValue
= (UINT64
) mMinMaxStepData
->u8
.MinValue
;
545 UINT64
GetMaxData (UINT8 VarType
) {
548 case EFI_IFR_TYPE_NUM_SIZE_64
:
549 MaxValue
= mMinMaxStepData
->u64
.MaxValue
;
551 case EFI_IFR_TYPE_NUM_SIZE_32
:
552 MaxValue
= (UINT64
) mMinMaxStepData
->u32
.MaxValue
;
554 case EFI_IFR_TYPE_NUM_SIZE_16
:
555 MaxValue
= (UINT64
) mMinMaxStepData
->u16
.MaxValue
;
557 case EFI_IFR_TYPE_NUM_SIZE_8
:
558 MaxValue
= (UINT64
) mMinMaxStepData
->u8
.MaxValue
;
566 UINT64
GetStepData (UINT8 VarType
) {
569 case EFI_IFR_TYPE_NUM_SIZE_64
:
570 MaxValue
= mMinMaxStepData
->u64
.Step
;
572 case EFI_IFR_TYPE_NUM_SIZE_32
:
573 MaxValue
= (UINT64
) mMinMaxStepData
->u32
.Step
;
575 case EFI_IFR_TYPE_NUM_SIZE_16
:
576 MaxValue
= (UINT64
) mMinMaxStepData
->u16
.Step
;
578 case EFI_IFR_TYPE_NUM_SIZE_8
:
579 MaxValue
= (UINT64
) mMinMaxStepData
->u8
.Step
;
587 BOOLEAN
IsNumericOpcode () {
591 VOID
UpdateCIfrMinMaxStepData (IN MINMAXSTEP_DATA
*MinMaxStepData
) {
592 mMinMaxStepData
= MinMaxStepData
;
596 static CIfrQuestionHeader
*gCurrentQuestion
= NULL
;
597 static CIfrMinMaxStepData
*gCurrentMinMaxData
= NULL
;
600 * The definition of all of the UEFI IFR Objects
602 class CIfrFormSet
: public CIfrObj
, public CIfrOpHeader
{
604 EFI_IFR_FORM_SET
*mFormSet
;
605 EFI_GUID
*mClassGuid
;
608 CIfrFormSet (UINT8 Size
) : CIfrObj (EFI_IFR_FORM_SET_OP
, (CHAR8
**)&mFormSet
, Size
),
609 CIfrOpHeader (EFI_IFR_FORM_SET_OP
, &mFormSet
->Header
, Size
) {
610 mFormSet
->Help
= EFI_STRING_ID_INVALID
;
611 mFormSet
->FormSetTitle
= EFI_STRING_ID_INVALID
;
613 memset (&mFormSet
->Guid
, 0, sizeof (EFI_GUID
));
614 mClassGuid
= (EFI_GUID
*) (mFormSet
+ 1);
617 VOID
SetGuid (IN EFI_GUID
*Guid
) {
618 memmove (&mFormSet
->Guid
, Guid
, sizeof (EFI_GUID
));
621 VOID
SetFormSetTitle (IN EFI_STRING_ID FormSetTitle
) {
622 mFormSet
->FormSetTitle
= FormSetTitle
;
625 VOID
SetHelp (IN EFI_STRING_ID Help
) {
626 mFormSet
->Help
= Help
;
629 VOID
SetClassGuid (IN EFI_GUID
*Guid
) {
630 memmove (&(mClassGuid
[mFormSet
->Flags
++]), Guid
, sizeof (EFI_GUID
));
634 return mFormSet
->Flags
;
638 class CIfrEnd
: public CIfrObj
, public CIfrOpHeader
{
643 CIfrEnd () : CIfrObj (EFI_IFR_END_OP
, (CHAR8
**)&mEnd
),
644 CIfrOpHeader (EFI_IFR_END_OP
, &mEnd
->Header
) {}
647 class CIfrDefaultStore
: public CIfrObj
, public CIfrOpHeader
{
649 EFI_IFR_DEFAULTSTORE
*mDefaultStore
;
652 CIfrDefaultStore () : CIfrObj (EFI_IFR_DEFAULTSTORE_OP
, (CHAR8
**)&mDefaultStore
),
653 CIfrOpHeader (EFI_IFR_DEFAULTSTORE_OP
, &mDefaultStore
->Header
) {
654 mDefaultStore
->DefaultId
= EFI_VARSTORE_ID_INVALID
;
655 mDefaultStore
->DefaultName
= EFI_STRING_ID_INVALID
;
658 VOID
SetDefaultName (IN EFI_STRING_ID DefaultName
) {
659 mDefaultStore
->DefaultName
= DefaultName
;
662 VOID
SetDefaultId (IN UINT16 DefaultId
) {
663 mDefaultStore
->DefaultId
= DefaultId
;
667 #define EFI_FORM_ID_MAX 0xFFFF
668 #define EFI_FREE_FORM_ID_BITMAP_SIZE ((EFI_FORM_ID_MAX + 1) / EFI_BITS_PER_UINT32)
672 STATIC UINT32 FormIdBitMap
[EFI_FREE_FORM_ID_BITMAP_SIZE
];
674 STATIC BOOLEAN
ChekFormIdFree (IN EFI_FORM_ID FormId
) {
675 UINT32 Index
= (FormId
/ EFI_BITS_PER_UINT32
);
676 UINT32 Offset
= (FormId
% EFI_BITS_PER_UINT32
);
678 return (FormIdBitMap
[Index
] & (0x80000000 >> Offset
)) == 0;
681 STATIC VOID
MarkFormIdUsed (IN EFI_FORM_ID FormId
) {
682 UINT32 Index
= (FormId
/ EFI_BITS_PER_UINT32
);
683 UINT32 Offset
= (FormId
% EFI_BITS_PER_UINT32
);
685 FormIdBitMap
[Index
] |= (0x80000000 >> Offset
);
689 class CIfrForm
: public CIfrObj
, public CIfrOpHeader
{
694 CIfrForm () : CIfrObj (EFI_IFR_FORM_OP
, (CHAR8
**)&mForm
),
695 CIfrOpHeader (EFI_IFR_FORM_OP
, &mForm
->Header
) {
697 mForm
->FormTitle
= EFI_STRING_ID_INVALID
;
700 EFI_VFR_RETURN_CODE
SetFormId (IN EFI_FORM_ID FormId
) {
703 // FormId can't be 0.
705 return VFR_RETURN_INVALID_PARAMETER
;
707 if (CIfrFormId::ChekFormIdFree (FormId
) == FALSE
) {
708 return VFR_RETURN_FORMID_REDEFINED
;
710 mForm
->FormId
= FormId
;
711 CIfrFormId::MarkFormIdUsed (FormId
);
712 return VFR_RETURN_SUCCESS
;
715 VOID
SetFormTitle (IN EFI_STRING_ID FormTitle
) {
716 mForm
->FormTitle
= FormTitle
;
720 class CIfrFormMap
: public CIfrObj
, public CIfrOpHeader
{
722 EFI_IFR_FORM_MAP
*mFormMap
;
723 EFI_IFR_FORM_MAP_METHOD
*mMethodMap
;
726 CIfrFormMap () : CIfrObj (EFI_IFR_FORM_MAP_OP
, (CHAR8
**)&mFormMap
, sizeof (EFI_IFR_FORM_MAP
), TRUE
),
727 CIfrOpHeader (EFI_IFR_FORM_MAP_OP
, &mFormMap
->Header
) {
728 mFormMap
->FormId
= 0;
729 mMethodMap
= (EFI_IFR_FORM_MAP_METHOD
*) (mFormMap
+ 1);
732 EFI_VFR_RETURN_CODE
SetFormId (IN EFI_FORM_ID FormId
) {
735 // FormId can't be 0.
737 return VFR_RETURN_INVALID_PARAMETER
;
739 if (CIfrFormId::ChekFormIdFree (FormId
) == FALSE
) {
740 return VFR_RETURN_FORMID_REDEFINED
;
742 mFormMap
->FormId
= FormId
;
743 CIfrFormId::MarkFormIdUsed (FormId
);
744 return VFR_RETURN_SUCCESS
;
747 VOID
SetFormMapMethod (IN EFI_STRING_ID MethodTitle
, IN EFI_GUID
*MethodGuid
) {
748 if (ExpendObjBin (sizeof (EFI_IFR_FORM_MAP_METHOD
))) {
749 IncLength (sizeof (EFI_IFR_FORM_MAP_METHOD
));
751 mMethodMap
->MethodTitle
= MethodTitle
;
752 memmove (&(mMethodMap
->MethodIdentifier
), MethodGuid
, sizeof (EFI_GUID
));
758 class CIfrVarStore
: public CIfrObj
, public CIfrOpHeader
{
760 EFI_IFR_VARSTORE
*mVarStore
;
763 CIfrVarStore () : CIfrObj (EFI_IFR_VARSTORE_OP
, (CHAR8
**)&mVarStore
, sizeof (EFI_IFR_VARSTORE
), TRUE
),
764 CIfrOpHeader (EFI_IFR_VARSTORE_OP
, &mVarStore
->Header
) {
765 mVarStore
->VarStoreId
= EFI_VARSTORE_ID_INVALID
;
767 memset (&mVarStore
->Guid
, 0, sizeof (EFI_GUID
));
768 mVarStore
->Name
[0] = '\0';
771 VOID
SetGuid (IN EFI_GUID
*Guid
) {
772 memmove (&mVarStore
->Guid
, Guid
, sizeof (EFI_GUID
));
775 VOID
SetVarStoreId (IN EFI_VARSTORE_ID VarStoreId
) {
776 mVarStore
->VarStoreId
= VarStoreId
;
779 VOID
SetSize (IN UINT16 Size
) {
780 mVarStore
->Size
= Size
;
783 VOID
SetName (IN CHAR8
*Name
) {
787 Len
= (UINT8
) strlen (Name
);
789 if (ExpendObjBin (Len
) == TRUE
) {
791 strcpy ((CHAR8
*)(mVarStore
->Name
), Name
);
798 class CIfrVarStoreEfi
: public CIfrObj
, public CIfrOpHeader
{
800 EFI_IFR_VARSTORE_EFI
*mVarStoreEfi
;
803 CIfrVarStoreEfi () : CIfrObj (EFI_IFR_VARSTORE_EFI_OP
, (CHAR8
**)&mVarStoreEfi
, sizeof (EFI_IFR_VARSTORE_EFI
), TRUE
),
804 CIfrOpHeader (EFI_IFR_VARSTORE_EFI_OP
, &mVarStoreEfi
->Header
) {
805 mVarStoreEfi
->VarStoreId
= EFI_VAROFFSET_INVALID
;
806 mVarStoreEfi
->Size
= 0;
807 memset (&mVarStoreEfi
->Guid
, 0, sizeof (EFI_GUID
));
808 mVarStoreEfi
->Name
[0] = '\0';
811 VOID
SetGuid (IN EFI_GUID
*Guid
) {
812 memmove (&mVarStoreEfi
->Guid
, Guid
, sizeof (EFI_GUID
));
815 VOID
SetVarStoreId (IN UINT16 VarStoreId
) {
816 mVarStoreEfi
->VarStoreId
= VarStoreId
;
819 VOID
SetAttributes (IN UINT32 Attributes
) {
820 mVarStoreEfi
->Attributes
= Attributes
;
822 VOID
SetSize (IN UINT16 Size
) {
823 mVarStoreEfi
->Size
= Size
;
826 VOID
SetName (IN CHAR8
*Name
) {
830 Len
= (UINT8
) strlen (Name
);
832 if (ExpendObjBin (Len
) == TRUE
) {
834 strcpy ((CHAR8
*)(mVarStoreEfi
->Name
), Name
);
840 VOID
SetBinaryLength (IN UINT16 Size
) {
843 Len
= sizeof (EFI_IFR_VARSTORE_EFI
);
845 ExpendObjBin(Size
- Len
);
846 IncLength(Size
- Len
);
848 ShrinkObjBin(Len
- Size
);
849 DecLength(Len
- Size
);
854 class CIfrVarStoreNameValue
: public CIfrObj
, public CIfrOpHeader
{
856 EFI_IFR_VARSTORE_NAME_VALUE
*mVarStoreNameValue
;
859 CIfrVarStoreNameValue () : CIfrObj (EFI_IFR_VARSTORE_NAME_VALUE_OP
, (CHAR8
**)&mVarStoreNameValue
),
860 CIfrOpHeader (EFI_IFR_VARSTORE_NAME_VALUE_OP
, &mVarStoreNameValue
->Header
) {
861 mVarStoreNameValue
->VarStoreId
= EFI_VAROFFSET_INVALID
;
862 memset (&mVarStoreNameValue
->Guid
, 0, sizeof (EFI_GUID
));
865 VOID
SetGuid (IN EFI_GUID
*Guid
) {
866 memmove (&mVarStoreNameValue
->Guid
, Guid
, sizeof (EFI_GUID
));
869 VOID
SetVarStoreId (IN UINT16 VarStoreId
) {
870 mVarStoreNameValue
->VarStoreId
= VarStoreId
;
874 class CIfrImage
: public CIfrObj
, public CIfrOpHeader
{
876 EFI_IFR_IMAGE
*mImage
;
879 CIfrImage () : CIfrObj (EFI_IFR_IMAGE_OP
, (CHAR8
**)&mImage
),
880 CIfrOpHeader (EFI_IFR_IMAGE_OP
, &mImage
->Header
) {
881 mImage
->Id
= EFI_IMAGE_ID_INVALID
;
884 VOID
SetImageId (IN EFI_IMAGE_ID ImageId
) {
885 mImage
->Id
= ImageId
;
889 class CIfrModal
: public CIfrObj
, public CIfrOpHeader
{
891 EFI_IFR_MODAL_TAG
*mModal
;
894 CIfrModal () : CIfrObj (EFI_IFR_MODAL_TAG_OP
, (CHAR8
**)&mModal
),
895 CIfrOpHeader (EFI_IFR_MODAL_TAG_OP
, &mModal
->Header
) {
900 class CIfrLocked
: public CIfrObj
, public CIfrOpHeader
{
902 EFI_IFR_LOCKED
*mLocked
;
905 CIfrLocked () : CIfrObj (EFI_IFR_LOCKED_OP
, (CHAR8
**)&mLocked
),
906 CIfrOpHeader (EFI_IFR_LOCKED_OP
, &mLocked
->Header
) {}
909 class CIfrRule
: public CIfrObj
, public CIfrOpHeader
{
914 CIfrRule () : CIfrObj (EFI_IFR_RULE_OP
, (CHAR8
**)&mRule
),
915 mRule ((EFI_IFR_RULE
*)GetObjBinAddr()),
916 CIfrOpHeader (EFI_IFR_RULE_OP
, &mRule
->Header
) {
917 mRule
->RuleId
= EFI_RULE_ID_INVALID
;
920 VOID
SetRuleId (IN UINT8 RuleId
) {
921 mRule
->RuleId
= RuleId
;
925 static EFI_IFR_TYPE_VALUE gZeroEfiIfrTypeValue
= {0, };
927 class CIfrDefault
: public CIfrObj
, public CIfrOpHeader
{
929 EFI_IFR_DEFAULT
*mDefault
;
934 IN UINT16 DefaultId
= EFI_HII_DEFAULT_CLASS_STANDARD
,
935 IN UINT8 Type
= EFI_IFR_TYPE_OTHER
,
936 IN EFI_IFR_TYPE_VALUE Value
= gZeroEfiIfrTypeValue
937 ) : CIfrObj (EFI_IFR_DEFAULT_OP
, (CHAR8
**)&mDefault
, Size
),
938 CIfrOpHeader (EFI_IFR_DEFAULT_OP
, &mDefault
->Header
, Size
) {
939 mDefault
->Type
= Type
;
940 mDefault
->DefaultId
= DefaultId
;
941 memmove (&(mDefault
->Value
), &Value
, Size
- OFFSET_OF (EFI_IFR_DEFAULT
, Value
));
944 VOID
SetDefaultId (IN UINT16 DefaultId
) {
945 mDefault
->DefaultId
= DefaultId
;
948 VOID
SetType (IN UINT8 Type
) {
949 mDefault
->Type
= Type
;
952 VOID
SetValue (IN EFI_IFR_TYPE_VALUE Value
) {
953 memmove (&mDefault
->Value
, &Value
, mDefault
->Header
.Length
- OFFSET_OF (EFI_IFR_DEFAULT
, Value
));
957 class CIfrDefault2
: public CIfrObj
, public CIfrOpHeader
{
959 EFI_IFR_DEFAULT_2
*mDefault
;
963 IN UINT16 DefaultId
= EFI_HII_DEFAULT_CLASS_STANDARD
,
964 IN UINT8 Type
= EFI_IFR_TYPE_OTHER
965 ) : CIfrObj (EFI_IFR_DEFAULT_OP
, (CHAR8
**)&mDefault
, sizeof (EFI_IFR_DEFAULT_2
)),
966 CIfrOpHeader (EFI_IFR_DEFAULT_OP
, &mDefault
->Header
, sizeof (EFI_IFR_DEFAULT_2
)) {
967 mDefault
->Type
= Type
;
968 mDefault
->DefaultId
= DefaultId
;
971 VOID
SetDefaultId (IN UINT16 DefaultId
) {
972 mDefault
->DefaultId
= DefaultId
;
975 VOID
SetType (IN UINT8 Type
) {
976 mDefault
->Type
= Type
;
980 class CIfrValue
: public CIfrObj
, public CIfrOpHeader
{
982 EFI_IFR_VALUE
*mValue
;
985 CIfrValue () : CIfrObj (EFI_IFR_VALUE_OP
, (CHAR8
**)&mValue
),
986 CIfrOpHeader (EFI_IFR_VALUE_OP
, &mValue
->Header
) {}
990 class CIfrRead
: public CIfrObj
, public CIfrOpHeader
{
995 CIfrRead () : CIfrObj (EFI_IFR_READ_OP
, (CHAR8
**)&mRead
),
996 CIfrOpHeader (EFI_IFR_READ_OP
, &mRead
->Header
) {}
1000 class CIfrWrite
: public CIfrObj
, public CIfrOpHeader
{
1002 EFI_IFR_WRITE
*mWrite
;
1005 CIfrWrite () : CIfrObj (EFI_IFR_WRITE_OP
, (CHAR8
**)&mWrite
),
1006 CIfrOpHeader (EFI_IFR_WRITE_OP
, &mWrite
->Header
) {}
1010 class CIfrGet
: public CIfrObj
, public CIfrOpHeader
{
1017 ) : CIfrObj (EFI_IFR_GET_OP
, (CHAR8
**)&mGet
),
1018 CIfrOpHeader (EFI_IFR_GET_OP
, &mGet
->Header
) {
1022 VOID
SetVarInfo (IN EFI_VARSTORE_INFO
*Info
) {
1023 mGet
->VarStoreId
= Info
->mVarStoreId
;
1024 mGet
->VarStoreInfo
.VarName
= Info
->mInfo
.mVarName
;
1025 mGet
->VarStoreInfo
.VarOffset
= Info
->mInfo
.mVarOffset
;
1026 mGet
->VarStoreType
= Info
->mVarType
;
1030 class CIfrSet
: public CIfrObj
, public CIfrOpHeader
{
1037 ) : CIfrObj (EFI_IFR_SET_OP
, (CHAR8
**)&mSet
),
1038 CIfrOpHeader (EFI_IFR_SET_OP
, &mSet
->Header
) {
1042 VOID
SetVarInfo (IN EFI_VARSTORE_INFO
*Info
) {
1043 mSet
->VarStoreId
= Info
->mVarStoreId
;
1044 mSet
->VarStoreInfo
.VarName
= Info
->mInfo
.mVarName
;
1045 mSet
->VarStoreInfo
.VarOffset
= Info
->mInfo
.mVarOffset
;
1046 mSet
->VarStoreType
= Info
->mVarType
;
1050 class CIfrSubtitle
: public CIfrObj
, public CIfrOpHeader
, public CIfrStatementHeader
{
1052 EFI_IFR_SUBTITLE
*mSubtitle
;
1055 CIfrSubtitle () : CIfrObj (EFI_IFR_SUBTITLE_OP
, (CHAR8
**)&mSubtitle
),
1056 CIfrOpHeader (EFI_IFR_SUBTITLE_OP
, &mSubtitle
->Header
),
1057 CIfrStatementHeader (&mSubtitle
->Statement
) {
1058 mSubtitle
->Flags
= 0;
1061 EFI_VFR_RETURN_CODE
SetFlags (IN UINT8 LFlags
) {
1062 if (_FLAG_TEST_AND_CLEAR (LFlags
, EFI_IFR_FLAGS_HORIZONTAL
)) {
1063 mSubtitle
->Flags
|= EFI_IFR_FLAGS_HORIZONTAL
;
1066 return _FLAGS_ZERO (LFlags
) ? VFR_RETURN_SUCCESS
: VFR_RETURN_FLAGS_UNSUPPORTED
;
1070 class CIfrText
: public CIfrObj
, public CIfrOpHeader
, public CIfrStatementHeader
{
1072 EFI_IFR_TEXT
*mText
;
1075 CIfrText () : CIfrObj (EFI_IFR_TEXT_OP
, (CHAR8
**)&mText
),
1076 CIfrOpHeader (EFI_IFR_TEXT_OP
, &mText
->Header
),
1077 CIfrStatementHeader (&mText
->Statement
) {
1078 mText
->TextTwo
= EFI_STRING_ID_INVALID
;
1081 VOID
SetTextTwo (IN EFI_STRING_ID StringId
) {
1082 mText
->TextTwo
= StringId
;
1086 class CIfrRef
: public CIfrObj
, public CIfrOpHeader
, public CIfrQuestionHeader
{
1091 CIfrRef () : CIfrObj (EFI_IFR_REF_OP
, (CHAR8
**)&mRef
),
1092 CIfrOpHeader (EFI_IFR_REF_OP
, &mRef
->Header
),
1093 CIfrQuestionHeader (&mRef
->Question
) {
1097 VOID
SetFormId (IN EFI_FORM_ID FormId
) {
1098 mRef
->FormId
= FormId
;
1102 class CIfrRef2
: public CIfrObj
, public CIfrOpHeader
, public CIfrQuestionHeader
{
1104 EFI_IFR_REF2
*mRef2
;
1107 CIfrRef2 () : CIfrObj (EFI_IFR_REF_OP
, (CHAR8
**)&mRef2
, sizeof (EFI_IFR_REF2
)),
1108 CIfrOpHeader (EFI_IFR_REF_OP
, &mRef2
->Header
, sizeof (EFI_IFR_REF2
)),
1109 CIfrQuestionHeader (&mRef2
->Question
) {
1111 mRef2
->QuestionId
= EFI_QUESTION_ID_INVALID
;
1114 VOID
SetFormId (IN EFI_FORM_ID FormId
) {
1115 mRef2
->FormId
= FormId
;
1118 VOID
SetQuestionId (IN EFI_QUESTION_ID QuestionId
) {
1119 mRef2
->QuestionId
= QuestionId
;
1123 class CIfrRef3
: public CIfrObj
, public CIfrOpHeader
, public CIfrQuestionHeader
{
1125 EFI_IFR_REF3
*mRef3
;
1128 CIfrRef3 () : CIfrObj (EFI_IFR_REF_OP
, (CHAR8
**)&mRef3
, sizeof(EFI_IFR_REF3
)),
1129 CIfrOpHeader (EFI_IFR_REF_OP
, &mRef3
->Header
, sizeof (EFI_IFR_REF3
)),
1130 CIfrQuestionHeader (&mRef3
->Question
) {
1132 mRef3
->QuestionId
= EFI_QUESTION_ID_INVALID
;
1133 memset (&mRef3
->FormSetId
, 0, sizeof (EFI_GUID
));
1136 VOID
SetFormId (IN EFI_FORM_ID FormId
) {
1137 mRef3
->FormId
= FormId
;
1140 VOID
SetQuestionId (IN EFI_QUESTION_ID QuestionId
) {
1141 mRef3
->QuestionId
= QuestionId
;
1144 VOID
SetFormSetId (IN EFI_GUID FormSetId
) {
1145 mRef3
->FormSetId
= FormSetId
;
1149 class CIfrRef4
: public CIfrObj
, public CIfrOpHeader
, public CIfrQuestionHeader
{
1151 EFI_IFR_REF4
*mRef4
;
1154 CIfrRef4 () : CIfrObj (EFI_IFR_REF_OP
, (CHAR8
**)&mRef4
, sizeof(EFI_IFR_REF4
)),
1155 CIfrOpHeader (EFI_IFR_REF_OP
, &mRef4
->Header
, sizeof(EFI_IFR_REF4
)),
1156 CIfrQuestionHeader (&mRef4
->Question
) {
1158 mRef4
->QuestionId
= EFI_QUESTION_ID_INVALID
;
1159 memset (&mRef4
->FormSetId
, 0, sizeof (EFI_GUID
));
1160 mRef4
->DevicePath
= EFI_STRING_ID_INVALID
;
1163 VOID
SetFormId (IN EFI_FORM_ID FormId
) {
1164 mRef4
->FormId
= FormId
;
1167 VOID
SetQuestionId (IN EFI_QUESTION_ID QuestionId
) {
1168 mRef4
->QuestionId
= QuestionId
;
1171 VOID
SetFormSetId (IN EFI_GUID FormSetId
) {
1172 mRef4
->FormSetId
= FormSetId
;
1175 VOID
SetDevicePath (IN EFI_STRING_ID DevicePath
) {
1176 mRef4
->DevicePath
= DevicePath
;
1180 class CIfrRef5
: public CIfrObj
, public CIfrOpHeader
, public CIfrQuestionHeader
{
1182 EFI_IFR_REF5
*mRef5
;
1185 CIfrRef5 () : CIfrObj (EFI_IFR_REF_OP
, (CHAR8
**)&mRef5
, sizeof (EFI_IFR_REF5
)),
1186 CIfrOpHeader (EFI_IFR_REF_OP
, &mRef5
->Header
, sizeof (EFI_IFR_REF5
)),
1187 CIfrQuestionHeader (&mRef5
->Question
) {
1191 class CIfrResetButton
: public CIfrObj
, public CIfrOpHeader
, public CIfrStatementHeader
{
1193 EFI_IFR_RESET_BUTTON
*mResetButton
;
1196 CIfrResetButton () : CIfrObj (EFI_IFR_RESET_BUTTON_OP
, (CHAR8
**)&mResetButton
),
1197 CIfrOpHeader (EFI_IFR_RESET_BUTTON_OP
, &mResetButton
->Header
),
1198 CIfrStatementHeader (&mResetButton
->Statement
) {
1199 mResetButton
->DefaultId
= EFI_HII_DEFAULT_CLASS_STANDARD
;
1202 VOID
SetDefaultId (IN UINT16 DefaultId
) {
1203 mResetButton
->DefaultId
= DefaultId
;
1207 class CIfrCheckBox
: public CIfrObj
, public CIfrOpHeader
, public CIfrQuestionHeader
{
1209 EFI_IFR_CHECKBOX
*mCheckBox
;
1212 CIfrCheckBox () : CIfrObj (EFI_IFR_CHECKBOX_OP
, (CHAR8
**)&mCheckBox
),
1213 CIfrOpHeader (EFI_IFR_CHECKBOX_OP
, &mCheckBox
->Header
),
1214 CIfrQuestionHeader (&mCheckBox
->Question
) {
1215 mCheckBox
->Flags
= 0;
1216 gCurrentQuestion
= this;
1220 gCurrentQuestion
= NULL
;
1223 EFI_VFR_RETURN_CODE
SetFlags (IN UINT8 HFlags
, UINT8 LFlags
) {
1224 EFI_VFR_RETURN_CODE Ret
;
1226 Ret
= CIfrQuestionHeader::SetFlags (HFlags
);
1227 if (Ret
!= VFR_RETURN_SUCCESS
) {
1231 if (_FLAG_TEST_AND_CLEAR (LFlags
, EFI_IFR_CHECKBOX_DEFAULT
)) {
1232 mCheckBox
->Flags
|= EFI_IFR_CHECKBOX_DEFAULT
;
1235 if (_FLAG_TEST_AND_CLEAR (LFlags
, EFI_IFR_CHECKBOX_DEFAULT_MFG
)) {
1236 mCheckBox
->Flags
|= EFI_IFR_CHECKBOX_DEFAULT_MFG
;
1239 return _FLAGS_ZERO (LFlags
) ? VFR_RETURN_SUCCESS
: VFR_RETURN_FLAGS_UNSUPPORTED
;
1242 UINT8
GetFlags (VOID
) {
1243 return mCheckBox
->Flags
;
1247 class CIfrAction
: public CIfrObj
, public CIfrOpHeader
, public CIfrQuestionHeader
{
1249 EFI_IFR_ACTION
*mAction
;
1252 CIfrAction () : CIfrObj (EFI_IFR_ACTION_OP
, (CHAR8
**)&mAction
),
1253 CIfrOpHeader (EFI_IFR_ACTION_OP
, &mAction
->Header
),
1254 CIfrQuestionHeader (&mAction
->Question
) {
1255 mAction
->QuestionConfig
= EFI_STRING_ID_INVALID
;
1258 VOID
SetQuestionConfig (IN EFI_STRING_ID QuestionConfig
) {
1259 mAction
->QuestionConfig
= QuestionConfig
;
1263 class CIfrDate
: public CIfrObj
, public CIfrOpHeader
, public CIfrQuestionHeader
{
1265 EFI_IFR_DATE
*mDate
;
1268 CIfrDate () : CIfrObj (EFI_IFR_DATE_OP
, (CHAR8
**)&mDate
),
1269 CIfrOpHeader (EFI_IFR_DATE_OP
, &mDate
->Header
),
1270 CIfrQuestionHeader (&mDate
->Question
) {
1274 EFI_VFR_RETURN_CODE
SetFlags (IN UINT8 HFlags
, IN UINT8 LFlags
) {
1275 EFI_VFR_RETURN_CODE Ret
;
1277 Ret
= CIfrQuestionHeader::SetFlags (HFlags
);
1278 if (Ret
!= VFR_RETURN_SUCCESS
) {
1282 if (_FLAG_TEST_AND_CLEAR (LFlags
, EFI_QF_DATE_YEAR_SUPPRESS
)) {
1283 mDate
->Flags
|= EFI_QF_DATE_YEAR_SUPPRESS
;
1286 if (_FLAG_TEST_AND_CLEAR (LFlags
, EFI_QF_DATE_MONTH_SUPPRESS
)) {
1287 mDate
->Flags
|= EFI_QF_DATE_MONTH_SUPPRESS
;
1290 if (_FLAG_TEST_AND_CLEAR (LFlags
, EFI_QF_DATE_DAY_SUPPRESS
)) {
1291 mDate
->Flags
|= EFI_QF_DATE_DAY_SUPPRESS
;
1294 if (_FLAG_TEST_AND_CLEAR (LFlags
, QF_DATE_STORAGE_NORMAL
)) {
1295 mDate
->Flags
|= QF_DATE_STORAGE_NORMAL
;
1296 } else if (_FLAG_TEST_AND_CLEAR (LFlags
, QF_DATE_STORAGE_TIME
)) {
1297 mDate
->Flags
|= QF_DATE_STORAGE_TIME
;
1298 } else if (_FLAG_TEST_AND_CLEAR (LFlags
, QF_DATE_STORAGE_WAKEUP
)) {
1299 mDate
->Flags
|= QF_DATE_STORAGE_WAKEUP
;
1302 return _FLAGS_ZERO (LFlags
) ? VFR_RETURN_SUCCESS
: VFR_RETURN_FLAGS_UNSUPPORTED
;
1306 class CIfrNumeric
: public CIfrObj
, public CIfrOpHeader
, public CIfrQuestionHeader
, public CIfrMinMaxStepData
{
1308 EFI_IFR_NUMERIC
*mNumeric
;
1311 CIfrNumeric () : CIfrObj (EFI_IFR_NUMERIC_OP
, (CHAR8
**)&mNumeric
, sizeof (EFI_IFR_NUMERIC
), TRUE
),
1312 CIfrOpHeader (EFI_IFR_NUMERIC_OP
, &mNumeric
->Header
),
1313 CIfrQuestionHeader (&mNumeric
->Question
),
1314 CIfrMinMaxStepData (&mNumeric
->data
, TRUE
) {
1315 mNumeric
->Flags
= EFI_IFR_NUMERIC_SIZE_1
| EFI_IFR_DISPLAY_UINT_DEC
;
1316 gCurrentQuestion
= this;
1317 gCurrentMinMaxData
= this;
1321 gCurrentQuestion
= NULL
;
1322 gCurrentMinMaxData
= NULL
;
1325 VOID
ShrinkBinSize (IN UINT16 Size
) {
1327 // Update the buffer size which is truly be used later.
1333 // Allocate buffer in gCFormPkg.
1335 _EMIT_PENDING_OBJ();
1338 // Update the buffer pointer used by other class.
1340 mNumeric
= (EFI_IFR_NUMERIC
*) GetObjBinAddr();
1341 UpdateHeader (&mNumeric
->Header
);
1342 UpdateCIfrQuestionHeader(&mNumeric
->Question
);
1343 UpdateCIfrMinMaxStepData(&mNumeric
->data
);
1346 EFI_VFR_RETURN_CODE
SetFlags (IN UINT8 HFlags
, IN UINT8 LFlags
, BOOLEAN DisplaySettingsSpecified
= FALSE
) {
1347 EFI_VFR_RETURN_CODE Ret
;
1349 Ret
= CIfrQuestionHeader::SetFlags (HFlags
);
1350 if (Ret
!= VFR_RETURN_SUCCESS
) {
1354 if (DisplaySettingsSpecified
== FALSE
) {
1355 mNumeric
->Flags
= LFlags
| EFI_IFR_DISPLAY_UINT_DEC
;
1357 mNumeric
->Flags
= LFlags
;
1359 return VFR_RETURN_SUCCESS
;
1363 class CIfrOneOf
: public CIfrObj
, public CIfrOpHeader
, public CIfrQuestionHeader
, public CIfrMinMaxStepData
{
1365 EFI_IFR_ONE_OF
*mOneOf
;
1368 CIfrOneOf () : CIfrObj (EFI_IFR_ONE_OF_OP
, (CHAR8
**)&mOneOf
, sizeof (EFI_IFR_ONE_OF
), TRUE
),
1369 CIfrOpHeader (EFI_IFR_ONE_OF_OP
, &mOneOf
->Header
),
1370 CIfrQuestionHeader (&mOneOf
->Question
),
1371 CIfrMinMaxStepData (&mOneOf
->data
) {
1373 gCurrentQuestion
= this;
1374 gCurrentMinMaxData
= this;
1378 gCurrentQuestion
= NULL
;
1379 gCurrentMinMaxData
= NULL
;
1382 EFI_VFR_RETURN_CODE
SetFlags (IN UINT8 HFlags
, IN UINT8 LFlags
) {
1383 EFI_VFR_RETURN_CODE Ret
;
1385 Ret
= CIfrQuestionHeader::SetFlags (HFlags
);
1386 if (Ret
!= VFR_RETURN_SUCCESS
) {
1390 if (LFlags
& EFI_IFR_DISPLAY
) {
1391 mOneOf
->Flags
= LFlags
;
1393 mOneOf
->Flags
= LFlags
| EFI_IFR_DISPLAY_UINT_DEC
;
1395 return VFR_RETURN_SUCCESS
;
1398 VOID
ShrinkBinSize (IN UINT16 Size
) {
1400 // Update the buffer size which is truly be used later.
1406 // Allocate buffer in gCFormPkg.
1408 _EMIT_PENDING_OBJ();
1411 // Update the buffer pointer used by other class.
1413 mOneOf
= (EFI_IFR_ONE_OF
*) GetObjBinAddr();
1414 UpdateHeader (&mOneOf
->Header
);
1415 UpdateCIfrQuestionHeader(&mOneOf
->Question
);
1416 UpdateCIfrMinMaxStepData(&mOneOf
->data
);
1420 class CIfrString
: public CIfrObj
, public CIfrOpHeader
, public CIfrQuestionHeader
{
1422 EFI_IFR_STRING
*mString
;
1425 CIfrString () : CIfrObj (EFI_IFR_STRING_OP
, (CHAR8
**)&mString
),
1426 CIfrOpHeader (EFI_IFR_STRING_OP
, &mString
->Header
),
1427 CIfrQuestionHeader (&mString
->Question
) {
1429 mString
->MinSize
= 0;
1430 mString
->MaxSize
= 0;
1431 gCurrentQuestion
= this;
1435 gCurrentQuestion
= NULL
;
1438 EFI_VFR_RETURN_CODE
SetFlags (IN UINT8 HFlags
, IN UINT8 LFlags
) {
1439 EFI_VFR_RETURN_CODE Ret
;
1441 Ret
= CIfrQuestionHeader::SetFlags (HFlags
);
1442 if (Ret
!= VFR_RETURN_SUCCESS
) {
1446 if (_FLAG_TEST_AND_CLEAR (LFlags
, EFI_IFR_STRING_MULTI_LINE
)) {
1447 mString
->Flags
|= EFI_IFR_STRING_MULTI_LINE
;
1450 return _FLAGS_ZERO (LFlags
) ? VFR_RETURN_SUCCESS
: VFR_RETURN_FLAGS_UNSUPPORTED
;
1453 VOID
SetMinSize (IN UINT8 Flags
) {
1454 mString
->MinSize
= Flags
;
1457 VOID
SetMaxSize (IN UINT8 MaxSize
) {
1458 mString
->MaxSize
= MaxSize
;
1462 class CIfrPassword
: public CIfrObj
, public CIfrOpHeader
, public CIfrQuestionHeader
{
1464 EFI_IFR_PASSWORD
*mPassword
;
1467 CIfrPassword () : CIfrObj (EFI_IFR_PASSWORD_OP
, (CHAR8
**)&mPassword
),
1468 CIfrOpHeader (EFI_IFR_PASSWORD_OP
, &mPassword
->Header
),
1469 CIfrQuestionHeader (&mPassword
->Question
) {
1470 mPassword
->MinSize
= 0;
1471 mPassword
->MaxSize
= 0;
1472 gCurrentQuestion
= this;
1476 gCurrentQuestion
= NULL
;
1479 VOID
SetMinSize (IN UINT16 MinSize
) {
1480 mPassword
->MinSize
= MinSize
;
1483 VOID
SetMaxSize (IN UINT16 MaxSize
) {
1484 mPassword
->MaxSize
= MaxSize
;
1488 class CIfrOrderedList
: public CIfrObj
, public CIfrOpHeader
, public CIfrQuestionHeader
{
1490 EFI_IFR_ORDERED_LIST
*mOrderedList
;
1493 CIfrOrderedList () : CIfrObj (EFI_IFR_ORDERED_LIST_OP
, (CHAR8
**)&mOrderedList
),
1494 CIfrOpHeader (EFI_IFR_ORDERED_LIST_OP
, &mOrderedList
->Header
),
1495 CIfrQuestionHeader (&mOrderedList
->Question
) {
1496 mOrderedList
->MaxContainers
= 0;
1497 mOrderedList
->Flags
= 0;
1498 gCurrentQuestion
= this;
1501 ~CIfrOrderedList () {
1502 gCurrentQuestion
= NULL
;
1505 VOID
SetMaxContainers (IN UINT8 MaxContainers
) {
1506 mOrderedList
->MaxContainers
= MaxContainers
;
1509 EFI_VFR_RETURN_CODE
SetFlags (IN UINT8 HFlags
, IN UINT8 LFlags
) {
1510 EFI_VFR_RETURN_CODE Ret
;
1512 Ret
= CIfrQuestionHeader::SetFlags (HFlags
);
1513 if (Ret
!= VFR_RETURN_SUCCESS
) {
1517 if (_FLAG_TEST_AND_CLEAR (LFlags
, EFI_IFR_UNIQUE_SET
)) {
1518 mOrderedList
->Flags
|= EFI_IFR_UNIQUE_SET
;
1521 if (_FLAG_TEST_AND_CLEAR (LFlags
, EFI_IFR_NO_EMPTY_SET
)) {
1522 mOrderedList
->Flags
|= EFI_IFR_NO_EMPTY_SET
;
1525 return _FLAGS_ZERO (LFlags
) ? VFR_RETURN_SUCCESS
: VFR_RETURN_FLAGS_UNSUPPORTED
;
1529 class CIfrTime
: public CIfrObj
, public CIfrOpHeader
, public CIfrQuestionHeader
{
1531 EFI_IFR_TIME
*mTime
;
1534 CIfrTime () : CIfrObj (EFI_IFR_TIME_OP
, (CHAR8
**)&mTime
),
1535 CIfrOpHeader (EFI_IFR_TIME_OP
, &mTime
->Header
),
1536 CIfrQuestionHeader (&mTime
->Question
) {
1540 EFI_VFR_RETURN_CODE
SetFlags (IN UINT8 HFlags
, IN UINT8 LFlags
) {
1541 EFI_VFR_RETURN_CODE Ret
;
1543 Ret
= CIfrQuestionHeader::SetFlags (HFlags
);
1544 if (Ret
!= VFR_RETURN_SUCCESS
) {
1548 if (_FLAG_TEST_AND_CLEAR (LFlags
, QF_TIME_HOUR_SUPPRESS
)) {
1549 mTime
->Flags
|= QF_TIME_HOUR_SUPPRESS
;
1552 if (_FLAG_TEST_AND_CLEAR (LFlags
, QF_TIME_MINUTE_SUPPRESS
)) {
1553 mTime
->Flags
|= QF_TIME_MINUTE_SUPPRESS
;
1556 if (_FLAG_TEST_AND_CLEAR (LFlags
, QF_TIME_SECOND_SUPPRESS
)) {
1557 mTime
->Flags
|= QF_TIME_SECOND_SUPPRESS
;
1560 if (_FLAG_TEST_AND_CLEAR (LFlags
, QF_TIME_STORAGE_NORMAL
)) {
1561 mTime
->Flags
|= QF_TIME_STORAGE_NORMAL
;
1562 } else if (_FLAG_TEST_AND_CLEAR (LFlags
, QF_TIME_STORAGE_TIME
)) {
1563 mTime
->Flags
|= QF_TIME_STORAGE_TIME
;
1564 } else if (_FLAG_TEST_AND_CLEAR (LFlags
, QF_TIME_STORAGE_WAKEUP
)) {
1565 mTime
->Flags
|= QF_TIME_STORAGE_WAKEUP
;
1568 return _FLAGS_ZERO (LFlags
) ? VFR_RETURN_SUCCESS
: VFR_RETURN_FLAGS_UNSUPPORTED
;
1572 class CIfrDisableIf
: public CIfrObj
, public CIfrOpHeader
{
1574 EFI_IFR_DISABLE_IF
*mDisableIf
;
1577 CIfrDisableIf () : CIfrObj (EFI_IFR_DISABLE_IF_OP
, (CHAR8
**)&mDisableIf
),
1578 mDisableIf ((EFI_IFR_DISABLE_IF
*) GetObjBinAddr()),
1579 CIfrOpHeader (EFI_IFR_DISABLE_IF_OP
, &mDisableIf
->Header
) {}
1582 class CIfrSuppressIf
: public CIfrObj
, public CIfrOpHeader
{
1584 EFI_IFR_SUPPRESS_IF
*mSuppressIf
;
1587 CIfrSuppressIf () : CIfrObj (EFI_IFR_SUPPRESS_IF_OP
, (CHAR8
**)&mSuppressIf
),
1588 CIfrOpHeader (EFI_IFR_SUPPRESS_IF_OP
, &mSuppressIf
->Header
) {}
1591 class CIfrGrayOutIf
: public CIfrObj
, public CIfrOpHeader
{
1593 EFI_IFR_GRAY_OUT_IF
*mGrayOutIf
;
1596 CIfrGrayOutIf () : CIfrObj (EFI_IFR_GRAY_OUT_IF_OP
, (CHAR8
**)&mGrayOutIf
),
1597 CIfrOpHeader (EFI_IFR_GRAY_OUT_IF_OP
, &mGrayOutIf
->Header
) {}
1600 class CIfrInconsistentIf
: public CIfrObj
, public CIfrOpHeader
{
1602 EFI_IFR_INCONSISTENT_IF
*mInconsistentIf
;
1605 CIfrInconsistentIf () : CIfrObj (EFI_IFR_INCONSISTENT_IF_OP
, (CHAR8
**)&mInconsistentIf
),
1606 CIfrOpHeader (EFI_IFR_INCONSISTENT_IF_OP
, &mInconsistentIf
->Header
) {
1607 mInconsistentIf
->Error
= EFI_STRING_ID_INVALID
;
1610 VOID
SetError (IN EFI_STRING_ID Error
) {
1611 mInconsistentIf
->Error
= Error
;
1615 class CIfrWarningIf
: public CIfrObj
, public CIfrOpHeader
{
1617 EFI_IFR_WARNING_IF
*mWarningIf
;
1620 CIfrWarningIf () : CIfrObj (EFI_IFR_WARNING_IF_OP
, (CHAR8
**)&mWarningIf
),
1621 CIfrOpHeader (EFI_IFR_WARNING_IF_OP
, &mWarningIf
->Header
) {
1622 mWarningIf
->Warning
= EFI_STRING_ID_INVALID
;
1623 mWarningIf
->TimeOut
= 0;
1626 VOID
SetWarning (IN EFI_STRING_ID Warning
) {
1627 mWarningIf
->Warning
= Warning
;
1630 VOID
SetTimeOut (IN UINT8 TimeOut
) {
1631 mWarningIf
->TimeOut
= TimeOut
;
1635 class CIfrNoSubmitIf
: public CIfrObj
, public CIfrOpHeader
{
1637 EFI_IFR_NO_SUBMIT_IF
*mNoSubmitIf
;
1640 CIfrNoSubmitIf () : CIfrObj (EFI_IFR_NO_SUBMIT_IF_OP
, (CHAR8
**)&mNoSubmitIf
),
1641 CIfrOpHeader (EFI_IFR_NO_SUBMIT_IF_OP
, &mNoSubmitIf
->Header
) {
1642 mNoSubmitIf
->Error
= EFI_STRING_ID_INVALID
;
1645 VOID
SetError (IN EFI_STRING_ID Error
) {
1646 mNoSubmitIf
->Error
= Error
;
1650 class CIfrRefresh
: public CIfrObj
, public CIfrOpHeader
{
1652 EFI_IFR_REFRESH
*mRefresh
;
1655 CIfrRefresh () : CIfrObj (EFI_IFR_REFRESH_OP
, (CHAR8
**)&mRefresh
),
1656 CIfrOpHeader (EFI_IFR_REFRESH_OP
, &mRefresh
->Header
) {
1657 mRefresh
->RefreshInterval
= 0;
1660 VOID
SetRefreshInterval (IN UINT8 RefreshInterval
) {
1661 mRefresh
->RefreshInterval
= RefreshInterval
;
1665 class CIfrRefreshId
: public CIfrObj
, public CIfrOpHeader
{
1667 EFI_IFR_REFRESH_ID
*mRefreshId
;
1670 CIfrRefreshId () : CIfrObj (EFI_IFR_REFRESH_ID_OP
, (CHAR8
**)&mRefreshId
),
1671 CIfrOpHeader (EFI_IFR_REFRESH_ID_OP
, &mRefreshId
->Header
) {
1672 memset (&mRefreshId
->RefreshEventGroupId
, 0, sizeof (EFI_GUID
));
1675 VOID
SetRefreshEventGroutId (IN EFI_GUID
*RefreshEventGroupId
) {
1676 memmove (&mRefreshId
->RefreshEventGroupId
, RefreshEventGroupId
, sizeof (EFI_GUID
));
1680 class CIfrVarStoreDevice
: public CIfrObj
, public CIfrOpHeader
{
1682 EFI_IFR_VARSTORE_DEVICE
*mVarStoreDevice
;
1685 CIfrVarStoreDevice () : CIfrObj (EFI_IFR_VARSTORE_DEVICE_OP
, (CHAR8
**)&mVarStoreDevice
),
1686 CIfrOpHeader (EFI_IFR_VARSTORE_DEVICE_OP
, &mVarStoreDevice
->Header
) {
1687 mVarStoreDevice
->DevicePath
= EFI_STRING_ID_INVALID
;
1690 VOID
SetDevicePath (IN EFI_STRING_ID DevicePath
) {
1691 mVarStoreDevice
->DevicePath
= DevicePath
;
1695 class CIfrOneOfOption
: public CIfrObj
, public CIfrOpHeader
{
1697 EFI_IFR_ONE_OF_OPTION
*mOneOfOption
;
1700 CIfrOneOfOption (UINT8 Size
) : CIfrObj (EFI_IFR_ONE_OF_OPTION_OP
, (CHAR8
**)&mOneOfOption
, Size
),
1701 CIfrOpHeader (EFI_IFR_ONE_OF_OPTION_OP
, &mOneOfOption
->Header
, Size
) {
1702 mOneOfOption
->Flags
= 0;
1703 mOneOfOption
->Option
= EFI_STRING_ID_INVALID
;
1704 mOneOfOption
->Type
= EFI_IFR_TYPE_OTHER
;
1705 memset (&mOneOfOption
->Value
, 0, Size
- OFFSET_OF (EFI_IFR_ONE_OF_OPTION
, Value
));
1708 VOID
SetOption (IN EFI_STRING_ID Option
) {
1709 mOneOfOption
->Option
= Option
;
1712 EFI_VFR_RETURN_CODE
SetFlags (IN UINT8 LFlags
) {
1713 if (_FLAG_TEST_AND_CLEAR (LFlags
, EFI_IFR_OPTION_DEFAULT
)) {
1714 mOneOfOption
->Flags
|= EFI_IFR_OPTION_DEFAULT
;
1717 if (_FLAG_TEST_AND_CLEAR (LFlags
, EFI_IFR_OPTION_DEFAULT_MFG
)) {
1718 mOneOfOption
->Flags
|= EFI_IFR_OPTION_DEFAULT_MFG
;
1721 if (_IS_EQUAL (LFlags
, EFI_IFR_TYPE_NUM_SIZE_8
)) {
1722 _FLAG_CLEAR (LFlags
, EFI_IFR_TYPE_NUM_SIZE_8
);
1723 mOneOfOption
->Flags
|= EFI_IFR_TYPE_NUM_SIZE_8
;
1724 } else if (_IS_EQUAL (LFlags
, EFI_IFR_TYPE_NUM_SIZE_16
)) {
1725 _FLAG_CLEAR (LFlags
, EFI_IFR_TYPE_NUM_SIZE_16
);
1726 mOneOfOption
->Flags
|= EFI_IFR_TYPE_NUM_SIZE_16
;
1727 } else if (_IS_EQUAL (LFlags
, EFI_IFR_TYPE_NUM_SIZE_32
)) {
1728 _FLAG_CLEAR (LFlags
, EFI_IFR_TYPE_NUM_SIZE_32
);
1729 mOneOfOption
->Flags
|= EFI_IFR_TYPE_NUM_SIZE_32
;
1730 } else if (_IS_EQUAL (LFlags
, EFI_IFR_TYPE_NUM_SIZE_64
)) {
1731 _FLAG_CLEAR (LFlags
, EFI_IFR_TYPE_NUM_SIZE_64
);
1732 mOneOfOption
->Flags
|= EFI_IFR_TYPE_NUM_SIZE_64
;
1733 } else if (_IS_EQUAL (LFlags
, EFI_IFR_TYPE_BOOLEAN
)) {
1734 _FLAG_CLEAR (LFlags
, EFI_IFR_TYPE_BOOLEAN
);
1735 mOneOfOption
->Flags
|= EFI_IFR_TYPE_BOOLEAN
;
1736 } else if (_IS_EQUAL (LFlags
, EFI_IFR_TYPE_TIME
)) {
1737 _FLAG_CLEAR (LFlags
, EFI_IFR_TYPE_TIME
);
1738 mOneOfOption
->Flags
|= EFI_IFR_TYPE_TIME
;
1739 } else if (_IS_EQUAL (LFlags
, EFI_IFR_TYPE_DATE
)) {
1740 _FLAG_CLEAR (LFlags
, EFI_IFR_TYPE_DATE
);
1741 mOneOfOption
->Flags
|= EFI_IFR_TYPE_DATE
;
1742 } else if (_IS_EQUAL (LFlags
, EFI_IFR_TYPE_STRING
)) {
1743 _FLAG_CLEAR (LFlags
, EFI_IFR_TYPE_STRING
);
1744 mOneOfOption
->Flags
|= EFI_IFR_TYPE_STRING
;
1745 } else if (_IS_EQUAL (LFlags
, EFI_IFR_TYPE_OTHER
)) {
1746 _FLAG_CLEAR (LFlags
, EFI_IFR_TYPE_OTHER
);
1747 mOneOfOption
->Flags
|= EFI_IFR_TYPE_OTHER
;
1750 return _FLAGS_ZERO (LFlags
) ? VFR_RETURN_SUCCESS
: VFR_RETURN_FLAGS_UNSUPPORTED
;
1753 VOID
SetType (IN UINT8 Type
) {
1754 mOneOfOption
->Type
= Type
;
1757 VOID
SetValue (IN EFI_IFR_TYPE_VALUE Value
) {
1758 memmove (&mOneOfOption
->Value
, &Value
, mOneOfOption
->Header
.Length
- OFFSET_OF (EFI_IFR_ONE_OF_OPTION
, Value
));
1761 UINT8
GetFlags (VOID
) {
1762 return mOneOfOption
->Flags
;
1766 static EFI_GUID IfrTianoGuid
= EFI_IFR_TIANO_GUID
;
1767 static EFI_GUID IfrFrameworkGuid
= EFI_IFR_FRAMEWORK_GUID
;
1769 class CIfrClass
: public CIfrObj
, public CIfrOpHeader
{
1771 EFI_IFR_GUID_CLASS
*mClass
;
1774 CIfrClass () : CIfrObj (EFI_IFR_GUID_OP
, (CHAR8
**)&mClass
, sizeof (EFI_IFR_GUID_CLASS
)),
1775 CIfrOpHeader (EFI_IFR_GUID_OP
, &mClass
->Header
, sizeof (EFI_IFR_GUID_CLASS
)) {
1776 mClass
->ExtendOpCode
= EFI_IFR_EXTEND_OP_CLASS
;
1777 mClass
->Guid
= IfrTianoGuid
;
1778 mClass
->Class
= EFI_NON_DEVICE_CLASS
;
1781 VOID
SetClass (IN UINT16 Class
) {
1782 mClass
->Class
= Class
;
1786 class CIfrSubClass
: public CIfrObj
, public CIfrOpHeader
{
1788 EFI_IFR_GUID_SUBCLASS
*mSubClass
;
1791 CIfrSubClass () : CIfrObj (EFI_IFR_GUID_OP
, (CHAR8
**)&mSubClass
, sizeof (EFI_IFR_GUID_SUBCLASS
)),
1792 CIfrOpHeader (EFI_IFR_GUID_OP
, &mSubClass
->Header
, sizeof (EFI_IFR_GUID_SUBCLASS
)) {
1793 mSubClass
->ExtendOpCode
= EFI_IFR_EXTEND_OP_SUBCLASS
;
1794 mSubClass
->Guid
= IfrTianoGuid
;
1795 mSubClass
->SubClass
= EFI_SETUP_APPLICATION_SUBCLASS
;
1798 VOID
SetSubClass (IN UINT16 SubClass
) {
1799 mSubClass
->SubClass
= SubClass
;
1803 class CIfrLabel
: public CIfrObj
, public CIfrOpHeader
{
1805 EFI_IFR_GUID_LABEL
*mLabel
;
1808 CIfrLabel () : CIfrObj (EFI_IFR_GUID_OP
, (CHAR8
**)&mLabel
, sizeof (EFI_IFR_GUID_LABEL
)),
1809 CIfrOpHeader (EFI_IFR_GUID_OP
, &mLabel
->Header
, sizeof (EFI_IFR_GUID_LABEL
)) {
1810 mLabel
->ExtendOpCode
= EFI_IFR_EXTEND_OP_LABEL
;
1811 mLabel
->Guid
= IfrTianoGuid
;
1814 VOID
SetNumber (IN UINT16 Number
) {
1815 mLabel
->Number
= Number
;
1819 class CIfrBanner
: public CIfrObj
, public CIfrOpHeader
{
1821 EFI_IFR_GUID_BANNER
*mBanner
;
1824 CIfrBanner () : CIfrObj (EFI_IFR_GUID_OP
, (CHAR8
**)&mBanner
, sizeof (EFI_IFR_GUID_BANNER
)),
1825 CIfrOpHeader (EFI_IFR_GUID_OP
, &mBanner
->Header
, sizeof (EFI_IFR_GUID_BANNER
)) {
1826 mBanner
->ExtendOpCode
= EFI_IFR_EXTEND_OP_BANNER
;
1827 mBanner
->Guid
= IfrTianoGuid
;
1830 VOID
SetTitle (IN EFI_STRING_ID StringId
) {
1831 mBanner
->Title
= StringId
;
1834 VOID
SetLine (IN UINT16 Line
) {
1835 mBanner
->LineNumber
= Line
;
1838 VOID
SetAlign (IN UINT8 Align
) {
1839 mBanner
->Alignment
= Align
;
1843 class CIfrOptionKey
: public CIfrObj
, public CIfrOpHeader
{
1845 EFI_IFR_GUID_OPTIONKEY
*mOptionKey
;
1849 IN EFI_QUESTION_ID QuestionId
,
1850 IN EFI_IFR_TYPE_VALUE
&OptionValue
,
1851 IN EFI_QUESTION_ID KeyValue
1852 ) : CIfrObj (EFI_IFR_GUID_OP
, (CHAR8
**)&mOptionKey
, sizeof (EFI_IFR_GUID_OPTIONKEY
)),
1853 CIfrOpHeader (EFI_IFR_GUID_OP
, &mOptionKey
->Header
, sizeof (EFI_IFR_GUID_OPTIONKEY
)) {
1854 mOptionKey
->ExtendOpCode
= EFI_IFR_EXTEND_OP_OPTIONKEY
;
1855 mOptionKey
->Guid
= IfrFrameworkGuid
;
1856 mOptionKey
->QuestionId
= QuestionId
;
1857 mOptionKey
->OptionValue
= OptionValue
;
1858 mOptionKey
->KeyValue
= KeyValue
;
1862 class CIfrVarEqName
: public CIfrObj
, public CIfrOpHeader
{
1864 EFI_IFR_GUID_VAREQNAME
*mVarEqName
;
1868 IN EFI_QUESTION_ID QuestionId
,
1869 IN EFI_STRING_ID NameId
1870 ) : CIfrObj (EFI_IFR_GUID_OP
, (CHAR8
**)&mVarEqName
, sizeof (EFI_IFR_GUID_VAREQNAME
)),
1871 CIfrOpHeader (EFI_IFR_GUID_OP
, &mVarEqName
->Header
, sizeof (EFI_IFR_GUID_VAREQNAME
)) {
1872 mVarEqName
->ExtendOpCode
= EFI_IFR_EXTEND_OP_VAREQNAME
;
1873 mVarEqName
->Guid
= IfrFrameworkGuid
;
1874 mVarEqName
->QuestionId
= QuestionId
;
1875 mVarEqName
->NameId
= NameId
;
1879 class CIfrTimeout
: public CIfrObj
, public CIfrOpHeader
{
1881 EFI_IFR_GUID_TIMEOUT
*mTimeout
;
1884 CIfrTimeout (IN UINT16 Timeout
= 0) : CIfrObj (EFI_IFR_GUID_OP
, (CHAR8
**)&mTimeout
, sizeof (EFI_IFR_GUID_TIMEOUT
)),
1885 CIfrOpHeader (EFI_IFR_GUID_OP
, &mTimeout
->Header
, sizeof (EFI_IFR_GUID_TIMEOUT
)) {
1886 mTimeout
->ExtendOpCode
= EFI_IFR_EXTEND_OP_TIMEOUT
;
1887 mTimeout
->Guid
= IfrTianoGuid
;
1888 mTimeout
->TimeOut
= Timeout
;
1891 VOID
SetTimeout (IN UINT16 Timeout
) {
1892 mTimeout
->TimeOut
= Timeout
;
1896 class CIfrGuid
: public CIfrObj
, public CIfrOpHeader
{
1898 EFI_IFR_GUID
*mGuid
;
1901 CIfrGuid (UINT8 Size
) : CIfrObj (EFI_IFR_GUID_OP
, (CHAR8
**)&mGuid
, sizeof (EFI_IFR_GUID
)+Size
),
1902 CIfrOpHeader (EFI_IFR_GUID_OP
, &mGuid
->Header
, sizeof (EFI_IFR_GUID
)+Size
) {
1903 memset (&mGuid
->Guid
, 0, sizeof (EFI_GUID
));
1906 VOID
SetGuid (IN EFI_GUID
*Guid
) {
1907 memmove (&mGuid
->Guid
, Guid
, sizeof (EFI_GUID
));
1910 VOID
SetData (IN UINT8
* DataBuff
, IN UINT8 Size
) {
1911 memmove ((UINT8
*)mGuid
+ sizeof (EFI_IFR_GUID
), DataBuff
, Size
);
1915 class CIfrDup
: public CIfrObj
, public CIfrOpHeader
{
1922 ) : CIfrObj (EFI_IFR_DUP_OP
, (CHAR8
**)&mDup
),
1923 CIfrOpHeader (EFI_IFR_DUP_OP
, &mDup
->Header
) {
1928 class CIfrEqIdId
: public CIfrObj
, public CIfrOpHeader
{
1930 EFI_IFR_EQ_ID_ID
*mEqIdId
;
1935 ) : CIfrObj (EFI_IFR_EQ_ID_ID_OP
, (CHAR8
**)&mEqIdId
),
1936 CIfrOpHeader (EFI_IFR_EQ_ID_ID_OP
, &mEqIdId
->Header
) {
1938 mEqIdId
->QuestionId1
= EFI_QUESTION_ID_INVALID
;
1939 mEqIdId
->QuestionId2
= EFI_QUESTION_ID_INVALID
;
1942 VOID
SetQuestionId1 (
1943 IN EFI_QUESTION_ID QuestionId
,
1947 if (QuestionId
!= EFI_QUESTION_ID_INVALID
) {
1948 mEqIdId
->QuestionId1
= QuestionId
;
1950 gCFormPkg
.AssignPending (VarIdStr
, (VOID
*)(&mEqIdId
->QuestionId1
), sizeof (EFI_QUESTION_ID
), LineNo
, NO_QST_REFED
);
1954 VOID
SetQuestionId2 (
1955 IN EFI_QUESTION_ID QuestionId
,
1959 if (QuestionId
!= EFI_QUESTION_ID_INVALID
) {
1960 mEqIdId
->QuestionId2
= QuestionId
;
1962 gCFormPkg
.AssignPending (VarIdStr
, (VOID
*)(&mEqIdId
->QuestionId2
), sizeof (EFI_QUESTION_ID
), LineNo
, NO_QST_REFED
);
1967 class CIfrEqIdVal
: public CIfrObj
, public CIfrOpHeader
{
1969 EFI_IFR_EQ_ID_VAL
*mEqIdVal
;
1974 ) : CIfrObj (EFI_IFR_EQ_ID_VAL_OP
, (CHAR8
**)&mEqIdVal
),
1975 CIfrOpHeader (EFI_IFR_EQ_ID_VAL_OP
, &mEqIdVal
->Header
) {
1977 mEqIdVal
->QuestionId
= EFI_QUESTION_ID_INVALID
;
1980 VOID
SetQuestionId (
1981 IN EFI_QUESTION_ID QuestionId
,
1985 if (QuestionId
!= EFI_QUESTION_ID_INVALID
) {
1986 mEqIdVal
->QuestionId
= QuestionId
;
1988 gCFormPkg
.AssignPending (VarIdStr
, (VOID
*)(&mEqIdVal
->QuestionId
), sizeof (EFI_QUESTION_ID
), LineNo
, NO_QST_REFED
);
1992 VOID
SetValue (IN UINT16 Value
) {
1993 mEqIdVal
->Value
= Value
;
1997 class CIfrEqIdList
: public CIfrObj
, public CIfrOpHeader
{
1999 EFI_IFR_EQ_ID_VAL_LIST
*mEqIdVList
;
2004 ) : CIfrObj (EFI_IFR_EQ_ID_VAL_LIST_OP
, (CHAR8
**)&mEqIdVList
, sizeof (EFI_IFR_EQ_ID_VAL_LIST
), TRUE
),
2005 CIfrOpHeader (EFI_IFR_EQ_ID_VAL_LIST_OP
, &mEqIdVList
->Header
) {
2007 mEqIdVList
->QuestionId
= EFI_QUESTION_ID_INVALID
;
2008 mEqIdVList
->ListLength
= 0;
2009 mEqIdVList
->ValueList
[0] = 0;
2012 VOID
UpdateIfrBuffer (
2014 _EMIT_PENDING_OBJ();
2015 mEqIdVList
= (EFI_IFR_EQ_ID_VAL_LIST
*) GetObjBinAddr();
2016 UpdateHeader (&mEqIdVList
->Header
);
2019 VOID
SetQuestionId (
2020 IN EFI_QUESTION_ID QuestionId
,
2024 if (QuestionId
!= EFI_QUESTION_ID_INVALID
) {
2025 mEqIdVList
->QuestionId
= QuestionId
;
2027 gCFormPkg
.AssignPending (VarIdStr
, (VOID
*)(&mEqIdVList
->QuestionId
), sizeof (EFI_QUESTION_ID
), LineNo
, NO_QST_REFED
);
2031 VOID
SetListLength (IN UINT16 ListLength
) {
2032 mEqIdVList
->ListLength
= ListLength
;
2035 VOID
SetValueList (IN UINT16 Index
, IN UINT16 Value
) {
2037 mEqIdVList
->ValueList
[0] = Value
;
2041 if (ExpendObjBin (sizeof (UINT16
)) ==TRUE
) {
2042 IncLength (sizeof (UINT16
));
2043 mEqIdVList
->ValueList
[Index
] = Value
;
2048 class CIfrQuestionRef1
: public CIfrObj
, public CIfrOpHeader
{
2050 EFI_IFR_QUESTION_REF1
*mQuestionRef1
;
2055 ) : CIfrObj (EFI_IFR_QUESTION_REF1_OP
, (CHAR8
**)&mQuestionRef1
),
2056 CIfrOpHeader (EFI_IFR_QUESTION_REF1_OP
, &mQuestionRef1
->Header
) {
2058 mQuestionRef1
->QuestionId
= EFI_QUESTION_ID_INVALID
;
2061 VOID
SetQuestionId (
2062 IN EFI_QUESTION_ID QuestionId
,
2066 if (QuestionId
!= EFI_QUESTION_ID_INVALID
) {
2067 mQuestionRef1
->QuestionId
= QuestionId
;
2069 gCFormPkg
.AssignPending (VarIdStr
, (VOID
*)(&mQuestionRef1
->QuestionId
), sizeof (EFI_QUESTION_ID
), LineNo
, NO_QST_REFED
);
2074 class CIfrQuestionRef2
: public CIfrObj
, public CIfrOpHeader
{
2076 EFI_IFR_QUESTION_REF2
*mQuestionRef2
;
2081 ) : CIfrObj (EFI_IFR_QUESTION_REF2_OP
, (CHAR8
**)&mQuestionRef2
),
2082 CIfrOpHeader (EFI_IFR_QUESTION_REF2_OP
, &mQuestionRef2
->Header
) {
2087 class CIfrQuestionRef3
: public CIfrObj
, public CIfrOpHeader
{
2089 EFI_IFR_QUESTION_REF3
*mQuestionRef3
;
2094 ) : CIfrObj (EFI_IFR_QUESTION_REF3_OP
, (CHAR8
**)&mQuestionRef3
),
2095 CIfrOpHeader (EFI_IFR_QUESTION_REF3_OP
, &mQuestionRef3
->Header
) {
2100 class CIfrQuestionRef3_2
: public CIfrObj
, public CIfrOpHeader
{
2102 EFI_IFR_QUESTION_REF3_2
*mQuestionRef3_2
;
2105 CIfrQuestionRef3_2 (
2107 ) : CIfrObj (EFI_IFR_QUESTION_REF3_OP
, (CHAR8
**)&mQuestionRef3_2
, sizeof (EFI_IFR_QUESTION_REF3_2
)),
2108 CIfrOpHeader (EFI_IFR_QUESTION_REF3_OP
, &mQuestionRef3_2
->Header
, sizeof (EFI_IFR_QUESTION_REF3_2
)) {
2110 mQuestionRef3_2
->DevicePath
= EFI_STRING_ID_INVALID
;
2113 VOID
SetDevicePath (IN EFI_STRING_ID DevicePath
) {
2114 mQuestionRef3_2
->DevicePath
= DevicePath
;
2118 class CIfrQuestionRef3_3
: public CIfrObj
, public CIfrOpHeader
{
2120 EFI_IFR_QUESTION_REF3_3
*mQuestionRef3_3
;
2123 CIfrQuestionRef3_3 (
2125 ) : CIfrObj (EFI_IFR_QUESTION_REF3_OP
, (CHAR8
**)&mQuestionRef3_3
, sizeof (EFI_IFR_QUESTION_REF3_3
)),
2126 CIfrOpHeader (EFI_IFR_QUESTION_REF3_OP
, &mQuestionRef3_3
->Header
, sizeof (EFI_IFR_QUESTION_REF3_3
)) {
2128 mQuestionRef3_3
->DevicePath
= EFI_STRING_ID_INVALID
;
2129 memset (&mQuestionRef3_3
->Guid
, 0, sizeof (EFI_GUID
));
2132 VOID
SetDevicePath (IN EFI_STRING_ID DevicePath
) {
2133 mQuestionRef3_3
->DevicePath
= DevicePath
;
2136 VOID
SetGuid (IN EFI_GUID
*Guid
) {
2137 mQuestionRef3_3
->Guid
= *Guid
;
2141 class CIfrRuleRef
: public CIfrObj
, public CIfrOpHeader
{
2143 EFI_IFR_RULE_REF
*mRuleRef
;
2148 ) : CIfrObj (EFI_IFR_RULE_REF_OP
, (CHAR8
**)&mRuleRef
),
2149 CIfrOpHeader (EFI_IFR_RULE_REF_OP
, &mRuleRef
->Header
) {
2151 mRuleRef
->RuleId
= EFI_RULE_ID_INVALID
;
2154 VOID
SetRuleId (IN UINT8 RuleId
) {
2155 mRuleRef
->RuleId
= RuleId
;
2159 class CIfrStringRef1
: public CIfrObj
, public CIfrOpHeader
{
2161 EFI_IFR_STRING_REF1
*mStringRef1
;
2166 ) : CIfrObj (EFI_IFR_STRING_REF1_OP
, (CHAR8
**)&mStringRef1
),
2167 CIfrOpHeader (EFI_IFR_STRING_REF1_OP
, &mStringRef1
->Header
) {
2169 mStringRef1
->StringId
= EFI_STRING_ID_INVALID
;
2172 VOID
SetStringId (IN EFI_STRING_ID StringId
) {
2173 mStringRef1
->StringId
= StringId
;
2177 class CIfrStringRef2
: public CIfrObj
, public CIfrOpHeader
{
2179 EFI_IFR_STRING_REF2
*mStringRef2
;
2184 ) : CIfrObj (EFI_IFR_STRING_REF2_OP
, (CHAR8
**)&mStringRef2
),
2185 CIfrOpHeader (EFI_IFR_STRING_REF2_OP
, &mStringRef2
->Header
) {
2190 class CIfrThis
: public CIfrObj
, public CIfrOpHeader
{
2192 EFI_IFR_THIS
*mThis
;
2197 ) : CIfrObj (EFI_IFR_THIS_OP
, (CHAR8
**)&mThis
),
2198 CIfrOpHeader (EFI_IFR_THIS_OP
, &mThis
->Header
) {
2203 class CIfrSecurity
: public CIfrObj
, public CIfrOpHeader
{
2205 EFI_IFR_SECURITY
*mSecurity
;
2210 ) : CIfrObj (EFI_IFR_SECURITY_OP
, (CHAR8
**)&mSecurity
),
2211 CIfrOpHeader (EFI_IFR_SECURITY_OP
, &mSecurity
->Header
) {
2213 memset (&mSecurity
->Permissions
, 0, sizeof (EFI_GUID
));
2216 VOID
SetPermissions (IN EFI_GUID
*Permissions
) {
2217 memmove (&mSecurity
->Permissions
, Permissions
, sizeof (EFI_GUID
));
2221 class CIfrUint8
: public CIfrObj
, public CIfrOpHeader
{
2223 EFI_IFR_UINT8
*mUint8
;
2228 ) : CIfrObj (EFI_IFR_UINT8_OP
, (CHAR8
**)&mUint8
),
2229 CIfrOpHeader (EFI_IFR_UINT8_OP
, &mUint8
->Header
) {
2233 VOID
SetValue (IN UINT8 Value
) {
2234 mUint8
->Value
= Value
;
2238 class CIfrUint16
: public CIfrObj
, public CIfrOpHeader
{
2240 EFI_IFR_UINT16
*mUint16
;
2245 ) : CIfrObj (EFI_IFR_UINT16_OP
, (CHAR8
**)&mUint16
),
2246 CIfrOpHeader (EFI_IFR_UINT16_OP
, &mUint16
->Header
) {
2250 VOID
SetValue (IN UINT16 Value
) {
2251 mUint16
->Value
= Value
;
2255 class CIfrUint32
: public CIfrObj
, public CIfrOpHeader
{
2257 EFI_IFR_UINT32
*mUint32
;
2262 ) : CIfrObj (EFI_IFR_UINT32_OP
, (CHAR8
**)&mUint32
),
2263 CIfrOpHeader (EFI_IFR_UINT32_OP
, &mUint32
->Header
) {
2267 VOID
SetValue (IN UINT32 Value
) {
2268 mUint32
->Value
= Value
;
2272 class CIfrUint64
: public CIfrObj
, public CIfrOpHeader
{
2274 EFI_IFR_UINT64
*mUint64
;
2279 ) : CIfrObj (EFI_IFR_UINT64_OP
, (CHAR8
**)&mUint64
),
2280 CIfrOpHeader (EFI_IFR_UINT64_OP
, &mUint64
->Header
) {
2284 VOID
SetValue (IN UINT64 Value
) {
2285 mUint64
->Value
= Value
;
2289 class CIfrTrue
: public CIfrObj
, public CIfrOpHeader
{
2291 EFI_IFR_TRUE
*mTrue
;
2296 ) : CIfrObj (EFI_IFR_TRUE_OP
, (CHAR8
**)&mTrue
),
2297 CIfrOpHeader (EFI_IFR_TRUE_OP
, &mTrue
->Header
) {
2302 class CIfrFalse
: public CIfrObj
, public CIfrOpHeader
{
2304 EFI_IFR_FALSE
*mFalse
;
2309 ) : CIfrObj (EFI_IFR_FALSE_OP
, (CHAR8
**)&mFalse
),
2310 CIfrOpHeader (EFI_IFR_FALSE_OP
, &mFalse
->Header
) {
2315 class CIfrOne
: public CIfrObj
, public CIfrOpHeader
{
2322 ) : CIfrObj (EFI_IFR_ONE_OP
, (CHAR8
**)&mOne
),
2323 CIfrOpHeader (EFI_IFR_ONE_OP
, &mOne
->Header
) {
2328 class CIfrOnes
: public CIfrObj
, public CIfrOpHeader
{
2330 EFI_IFR_ONES
*mOnes
;
2335 ) : CIfrObj (EFI_IFR_ONES_OP
, (CHAR8
**)&mOnes
),
2336 CIfrOpHeader (EFI_IFR_ONES_OP
, &mOnes
->Header
) {
2341 class CIfrZero
: public CIfrObj
, public CIfrOpHeader
{
2343 EFI_IFR_ZERO
*mZero
;
2348 ) : CIfrObj (EFI_IFR_ZERO_OP
, (CHAR8
**)&mZero
),
2349 CIfrOpHeader (EFI_IFR_ZERO_OP
, &mZero
->Header
) {
2354 class CIfrUndefined
: public CIfrObj
, public CIfrOpHeader
{
2356 EFI_IFR_UNDEFINED
*mUndefined
;
2361 ) : CIfrObj (EFI_IFR_UNDEFINED_OP
, (CHAR8
**)&mUndefined
),
2362 CIfrOpHeader (EFI_IFR_UNDEFINED_OP
, &mUndefined
->Header
) {
2367 class CIfrVersion
: public CIfrObj
, public CIfrOpHeader
{
2369 EFI_IFR_VERSION
*mVersion
;
2374 ) : CIfrObj (EFI_IFR_VERSION_OP
, (CHAR8
**)&mVersion
),
2375 CIfrOpHeader (EFI_IFR_VERSION_OP
, &mVersion
->Header
) {
2380 class CIfrLength
: public CIfrObj
, public CIfrOpHeader
{
2382 EFI_IFR_LENGTH
*mLength
;
2387 ) : CIfrObj (EFI_IFR_LENGTH_OP
, (CHAR8
**)&mLength
),
2388 CIfrOpHeader (EFI_IFR_LENGTH_OP
, &mLength
->Header
) {
2393 class CIfrNot
: public CIfrObj
, public CIfrOpHeader
{
2400 ) : CIfrObj (EFI_IFR_NOT_OP
, (CHAR8
**)&mNot
),
2401 CIfrOpHeader (EFI_IFR_NOT_OP
, &mNot
->Header
) {
2406 class CIfrBitWiseNot
: public CIfrObj
, public CIfrOpHeader
{
2408 EFI_IFR_BITWISE_NOT
*mBitWise
;
2413 ) : CIfrObj (EFI_IFR_BITWISE_NOT_OP
, (CHAR8
**)&mBitWise
),
2414 CIfrOpHeader (EFI_IFR_BITWISE_NOT_OP
, &mBitWise
->Header
) {
2419 class CIfrToBoolean
: public CIfrObj
, public CIfrOpHeader
{
2421 EFI_IFR_TO_BOOLEAN
*mToBoolean
;
2426 ) : CIfrObj (EFI_IFR_TO_BOOLEAN_OP
, (CHAR8
**)&mToBoolean
),
2427 CIfrOpHeader (EFI_IFR_TO_BOOLEAN_OP
, &mToBoolean
->Header
) {
2432 class CIfrToString
: public CIfrObj
, public CIfrOpHeader
{
2434 EFI_IFR_TO_STRING
*mToString
;
2439 ) : CIfrObj (EFI_IFR_TO_STRING_OP
, (CHAR8
**)&mToString
),
2440 CIfrOpHeader (EFI_IFR_TO_STRING_OP
, &mToString
->Header
) {
2444 VOID
SetFormat (IN UINT8 Format
) {
2445 mToString
->Format
= Format
;
2449 class CIfrToUint
: public CIfrObj
, public CIfrOpHeader
{
2451 EFI_IFR_TO_UINT
*mToUint
;
2456 ) : CIfrObj (EFI_IFR_TO_UINT_OP
, (CHAR8
**)&mToUint
),
2457 CIfrOpHeader (EFI_IFR_TO_UINT_OP
, &mToUint
->Header
) {
2462 class CIfrToUpper
: public CIfrObj
, public CIfrOpHeader
{
2464 EFI_IFR_TO_UPPER
*mToUpper
;
2469 ) : CIfrObj (EFI_IFR_TO_UPPER_OP
, (CHAR8
**)&mToUpper
),
2470 CIfrOpHeader (EFI_IFR_TO_UPPER_OP
, &mToUpper
->Header
) {
2475 class CIfrToLower
: public CIfrObj
, public CIfrOpHeader
{
2477 EFI_IFR_TO_LOWER
*mToLower
;
2482 ) : CIfrObj (EFI_IFR_TO_LOWER_OP
, (CHAR8
**)&mToLower
),
2483 CIfrOpHeader (EFI_IFR_TO_LOWER_OP
, &mToLower
->Header
) {
2488 class CIfrAdd
: public CIfrObj
, public CIfrOpHeader
{
2495 ) : CIfrObj (EFI_IFR_ADD_OP
, (CHAR8
**)&mAdd
),
2496 CIfrOpHeader (EFI_IFR_ADD_OP
, &mAdd
->Header
) {
2501 class CIfrBitWiseAnd
: public CIfrObj
, public CIfrOpHeader
{
2503 EFI_IFR_BITWISE_AND
*mBitWiseAnd
;
2508 ) : CIfrObj (EFI_IFR_BITWISE_AND_OP
, (CHAR8
**)&mBitWiseAnd
),
2509 CIfrOpHeader (EFI_IFR_BITWISE_AND_OP
, &mBitWiseAnd
->Header
) {
2514 class CIfrBitWiseOr
: public CIfrObj
, public CIfrOpHeader
{
2516 EFI_IFR_BITWISE_OR
*mBitWiseOr
;
2521 ) : CIfrObj (EFI_IFR_BITWISE_OR_OP
, (CHAR8
**)&mBitWiseOr
),
2522 CIfrOpHeader (EFI_IFR_BITWISE_OR_OP
, &mBitWiseOr
->Header
) {
2527 class CIfrAnd
: public CIfrObj
, public CIfrOpHeader
{
2534 ) : CIfrObj (EFI_IFR_AND_OP
, (CHAR8
**)&mAnd
),
2535 CIfrOpHeader (EFI_IFR_AND_OP
, &mAnd
->Header
) {
2540 class CIfrCatenate
: public CIfrObj
, public CIfrOpHeader
{
2542 EFI_IFR_CATENATE
*mCatenate
;
2547 ) : CIfrObj (EFI_IFR_CATENATE_OP
, (CHAR8
**)&mCatenate
),
2548 CIfrOpHeader (EFI_IFR_CATENATE_OP
, &mCatenate
->Header
) {
2553 class CIfrDivide
: public CIfrObj
, public CIfrOpHeader
{
2555 EFI_IFR_DIVIDE
*mDivide
;
2560 ) : CIfrObj (EFI_IFR_DIVIDE_OP
, (CHAR8
**)&mDivide
),
2561 CIfrOpHeader (EFI_IFR_DIVIDE_OP
, &mDivide
->Header
) {
2566 class CIfrEqual
: public CIfrObj
, public CIfrOpHeader
{
2568 EFI_IFR_EQUAL
*mEqual
;
2573 ) : CIfrObj (EFI_IFR_EQUAL_OP
, (CHAR8
**)&mEqual
),
2574 CIfrOpHeader (EFI_IFR_EQUAL_OP
, &mEqual
->Header
) {
2579 class CIfrGreaterEqual
: public CIfrObj
, public CIfrOpHeader
{
2581 EFI_IFR_GREATER_EQUAL
*mGreaterEqual
;
2586 ) : CIfrObj (EFI_IFR_GREATER_EQUAL_OP
, (CHAR8
**)&mGreaterEqual
),
2587 CIfrOpHeader (EFI_IFR_GREATER_EQUAL_OP
, &mGreaterEqual
->Header
) {
2592 class CIfrGreaterThan
: public CIfrObj
, public CIfrOpHeader
{
2594 EFI_IFR_GREATER_THAN
*mGreaterThan
;
2599 ) : CIfrObj (EFI_IFR_GREATER_THAN_OP
, (CHAR8
**)&mGreaterThan
),
2600 CIfrOpHeader (EFI_IFR_GREATER_THAN_OP
, &mGreaterThan
->Header
) {
2605 class CIfrLessEqual
: public CIfrObj
, public CIfrOpHeader
{
2607 EFI_IFR_LESS_EQUAL
*mLessEqual
;
2612 ) : CIfrObj (EFI_IFR_LESS_EQUAL_OP
, (CHAR8
**)&mLessEqual
),
2613 CIfrOpHeader (EFI_IFR_LESS_EQUAL_OP
, &mLessEqual
->Header
) {
2618 class CIfrLessThan
: public CIfrObj
, public CIfrOpHeader
{
2620 EFI_IFR_LESS_THAN
*mLessThan
;
2625 ) : CIfrObj (EFI_IFR_LESS_THAN_OP
, (CHAR8
**)&mLessThan
),
2626 CIfrOpHeader (EFI_IFR_LESS_THAN_OP
, &mLessThan
->Header
) {
2631 class CIfrMap
: public CIfrObj
, public CIfrOpHeader
{
2638 ) : CIfrObj (EFI_IFR_MAP_OP
, (CHAR8
**)&mMap
),
2639 CIfrOpHeader (EFI_IFR_MAP_OP
, &mMap
->Header
) {
2644 class CIfrMatch
: public CIfrObj
, public CIfrOpHeader
{
2646 EFI_IFR_MATCH
*mMatch
;
2651 ) : CIfrObj (EFI_IFR_MATCH_OP
, (CHAR8
**)&mMatch
),
2652 CIfrOpHeader (EFI_IFR_MATCH_OP
, &mMatch
->Header
) {
2657 class CIfrMultiply
: public CIfrObj
, public CIfrOpHeader
{
2659 EFI_IFR_MULTIPLY
*mMultiply
;
2664 ) : CIfrObj (EFI_IFR_MULTIPLY_OP
, (CHAR8
**)&mMultiply
),
2665 CIfrOpHeader (EFI_IFR_MULTIPLY_OP
, &mMultiply
->Header
) {
2670 class CIfrModulo
: public CIfrObj
, public CIfrOpHeader
{
2672 EFI_IFR_MODULO
*mModulo
;
2677 ) : CIfrObj (EFI_IFR_MODULO_OP
, (CHAR8
**)&mModulo
),
2678 CIfrOpHeader (EFI_IFR_MODULO_OP
, &mModulo
->Header
) {
2683 class CIfrNotEqual
: public CIfrObj
, public CIfrOpHeader
{
2685 EFI_IFR_NOT_EQUAL
*mNotEqual
;
2690 ) : CIfrObj (EFI_IFR_NOT_EQUAL_OP
, (CHAR8
**)&mNotEqual
),
2691 CIfrOpHeader (EFI_IFR_NOT_EQUAL_OP
, &mNotEqual
->Header
) {
2696 class CIfrOr
: public CIfrObj
, public CIfrOpHeader
{
2703 ) : CIfrObj (EFI_IFR_OR_OP
, (CHAR8
**)&mOr
),
2704 CIfrOpHeader (EFI_IFR_OR_OP
, &mOr
->Header
) {
2709 class CIfrShiftLeft
: public CIfrObj
, public CIfrOpHeader
{
2711 EFI_IFR_SHIFT_LEFT
*mShiftLeft
;
2716 ) : CIfrObj (EFI_IFR_SHIFT_LEFT_OP
, (CHAR8
**)&mShiftLeft
),
2717 CIfrOpHeader (EFI_IFR_SHIFT_LEFT_OP
, &mShiftLeft
->Header
) {
2722 class CIfrShiftRight
: public CIfrObj
, public CIfrOpHeader
{
2724 EFI_IFR_SHIFT_RIGHT
*mShiftRight
;
2729 ) : CIfrObj (EFI_IFR_SHIFT_RIGHT_OP
, (CHAR8
**)&mShiftRight
),
2730 CIfrOpHeader (EFI_IFR_SHIFT_RIGHT_OP
, &mShiftRight
->Header
) {
2735 class CIfrSubtract
: public CIfrObj
, public CIfrOpHeader
{
2737 EFI_IFR_SUBTRACT
*mSubtract
;
2742 ) : CIfrObj (EFI_IFR_SUBTRACT_OP
, (CHAR8
**)&mSubtract
),
2743 CIfrOpHeader (EFI_IFR_SUBTRACT_OP
, &mSubtract
->Header
) {
2748 class CIfrConditional
: public CIfrObj
, public CIfrOpHeader
{
2750 EFI_IFR_CONDITIONAL
*mConditional
;
2755 ) : CIfrObj (EFI_IFR_CONDITIONAL_OP
, (CHAR8
**)&mConditional
),
2756 CIfrOpHeader (EFI_IFR_CONDITIONAL_OP
, &mConditional
->Header
) {
2761 class CIfrFind
: public CIfrObj
, public CIfrOpHeader
{
2763 EFI_IFR_FIND
*mFind
;
2768 ) : CIfrObj (EFI_IFR_FIND_OP
, (CHAR8
**)&mFind
),
2769 CIfrOpHeader (EFI_IFR_FIND_OP
, &mFind
->Header
) {
2773 VOID
SetFormat (IN UINT8 Format
) {
2774 mFind
->Format
= Format
;
2778 class CIfrMid
: public CIfrObj
, public CIfrOpHeader
{
2785 ) : CIfrObj (EFI_IFR_MID_OP
, (CHAR8
**)&mMid
),
2786 CIfrOpHeader (EFI_IFR_MID_OP
, &mMid
->Header
) {
2791 class CIfrToken
: public CIfrObj
, public CIfrOpHeader
{
2793 EFI_IFR_TOKEN
*mToken
;
2798 ) : CIfrObj (EFI_IFR_TOKEN_OP
, (CHAR8
**)&mToken
),
2799 CIfrOpHeader (EFI_IFR_TOKEN_OP
, &mToken
->Header
) {
2804 class CIfrSpan
: public CIfrObj
, public CIfrOpHeader
{
2806 EFI_IFR_SPAN
*mSpan
;
2811 ) : CIfrObj (EFI_IFR_SPAN_OP
, (CHAR8
**)&mSpan
),
2812 CIfrOpHeader (EFI_IFR_SPAN_OP
, &mSpan
->Header
) {
2814 mSpan
->Flags
= EFI_IFR_FLAGS_FIRST_MATCHING
;
2817 EFI_VFR_RETURN_CODE
SetFlags (IN UINT8 LFlags
) {
2818 if (_IS_EQUAL (LFlags
, EFI_IFR_FLAGS_FIRST_MATCHING
)) {
2819 mSpan
->Flags
|= EFI_IFR_FLAGS_FIRST_MATCHING
;
2820 } else if (_FLAG_TEST_AND_CLEAR (LFlags
, EFI_IFR_FLAGS_FIRST_NON_MATCHING
)) {
2821 mSpan
->Flags
|= EFI_IFR_FLAGS_FIRST_NON_MATCHING
;
2824 return _FLAGS_ZERO (LFlags
) ? VFR_RETURN_SUCCESS
: VFR_RETURN_FLAGS_UNSUPPORTED
;