/** @file | |
The definition of CFormPkg's member function | |
Copyright (c) 2004 - 2019, Intel Corporation. All rights reserved.<BR> | |
SPDX-License-Identifier: BSD-2-Clause-Patent | |
**/ | |
#ifndef _EFIIFRCLASS_H_ | |
#define _EFIIFRCLASS_H_ | |
#include "string.h" | |
#include "EfiVfr.h" | |
#include "VfrError.h" | |
#include "VfrUtilityLib.h" | |
#define NO_QST_REFED "no question refered" | |
struct PACKAGE_DATA { | |
CHAR8 *Buffer; | |
UINT32 Size; | |
}; | |
/* | |
* The functions below are used for flags setting | |
*/ | |
static inline BOOLEAN _FLAGS_ZERO ( | |
IN UINT8 &Flags | |
) | |
{ | |
return Flags == 0; | |
} | |
static inline VOID _FLAG_CLEAR ( | |
IN UINT8 &Flags, | |
IN UINT8 Mask | |
) | |
{ | |
Flags &= (~Mask); | |
} | |
static inline UINT8 _FLAG_TEST_AND_CLEAR ( | |
IN UINT8 &Flags, | |
IN UINT8 Mask | |
) | |
{ | |
UINT8 Ret = Flags & Mask; | |
Flags &= (~Mask); | |
return Ret; | |
} | |
static inline UINT8 _IS_EQUAL ( | |
IN UINT8 &Flags, | |
IN UINT8 Value | |
) | |
{ | |
return Flags == Value; | |
} | |
/* | |
* The definition of CIfrBin | |
*/ | |
typedef enum { | |
PENDING, | |
ASSIGNED | |
} ASSIGN_FLAG; | |
struct SPendingAssign { | |
CHAR8 *mKey; // key ! unique | |
VOID *mAddr; | |
UINT32 mLen; | |
ASSIGN_FLAG mFlag; | |
UINT32 mLineNo; | |
CHAR8 *mMsg; | |
struct SPendingAssign *mNext; | |
SPendingAssign (IN CHAR8 *, IN VOID *, IN UINT32, IN UINT32, IN CONST CHAR8 *); | |
~SPendingAssign (); | |
VOID SetAddrAndLen (IN VOID *, IN UINT32); | |
VOID AssignValue (IN VOID *, IN UINT32); | |
CHAR8 * GetKey (VOID); | |
private: | |
SPendingAssign (IN CONST SPendingAssign&); // Prevent copy-construction | |
SPendingAssign& operator= (IN CONST SPendingAssign&); // Prevent assignment | |
}; | |
struct SBufferNode { | |
CHAR8 *mBufferStart; | |
CHAR8 *mBufferEnd; | |
CHAR8 *mBufferFree; | |
struct SBufferNode *mNext; | |
}; | |
typedef struct { | |
EFI_GUID *OverrideClassGuid; | |
} INPUT_INFO_TO_SYNTAX; | |
class CFormPkg { | |
private: | |
UINT32 mBufferSize; | |
SBufferNode *mBufferNodeQueueHead; | |
SBufferNode *mBufferNodeQueueTail; | |
SBufferNode *mCurrBufferNode; | |
SBufferNode *mReadBufferNode; | |
UINT32 mReadBufferOffset; | |
UINT32 mPkgLength; | |
VOID _WRITE_PKG_LINE (IN FILE *, IN UINT32 , IN CONST CHAR8 *, IN CHAR8 *, IN UINT32); | |
VOID _WRITE_PKG_END (IN FILE *, IN UINT32 , IN CONST CHAR8 *, IN CHAR8 *, IN UINT32); | |
SBufferNode * GetBinBufferNodeForAddr (IN CHAR8 *); | |
SBufferNode * CreateNewNode (); | |
SBufferNode * GetNodeBefore (IN SBufferNode *); | |
EFI_VFR_RETURN_CODE InsertNodeBefore (IN SBufferNode *, IN SBufferNode *); | |
private: | |
SPendingAssign *PendingAssignList; | |
public: | |
CFormPkg (IN UINT32 BufferSize = 4096); | |
~CFormPkg (); | |
CHAR8 * IfrBinBufferGet (IN UINT32); | |
inline UINT32 GetPkgLength (VOID); | |
VOID Open (); | |
UINT32 Read (IN CHAR8 *, IN UINT32); | |
VOID Close (); | |
EFI_VFR_RETURN_CODE BuildPkgHdr (OUT EFI_HII_PACKAGE_HEADER **); | |
EFI_VFR_RETURN_CODE BuildPkg (IN FILE *, IN PACKAGE_DATA *PkgData = NULL); | |
EFI_VFR_RETURN_CODE BuildPkg (OUT PACKAGE_DATA &); | |
EFI_VFR_RETURN_CODE GenCFile (IN CHAR8 *, IN FILE *, IN PACKAGE_DATA *PkgData = NULL); | |
private: | |
CFormPkg (IN CONST CFormPkg&); // Prevent copy-construction | |
CFormPkg& operator= (IN CONST CFormPkg&); // Prevent assignment | |
public: | |
EFI_VFR_RETURN_CODE AssignPending (IN CHAR8 *, IN VOID *, IN UINT32, IN UINT32, IN CONST CHAR8 *Msg = NULL); | |
VOID DoPendingAssign (IN CHAR8 *, IN VOID *, IN UINT32); | |
bool HavePendingUnassigned (VOID); | |
VOID PendingAssignPrintAll (VOID); | |
EFI_VFR_RETURN_CODE DeclarePendingQuestion ( | |
IN CVfrVarDataTypeDB &lCVfrVarDataTypeDB, | |
IN CVfrDataStorage &lCVfrDataStorage, | |
IN CVfrQuestionDB &lCVfrQuestionDB, | |
IN EFI_GUID *LocalFormSetGuid, | |
IN UINT32 LineNo, | |
OUT CHAR8 **InsertOpcodeAddr | |
); | |
EFI_VFR_RETURN_CODE AdjustDynamicInsertOpcode ( | |
IN CHAR8 *LastFormEndAddr, | |
IN CHAR8 *InsertOpcodeAddr, | |
IN BOOLEAN CreateOpcodeAfterParsingVfr | |
); | |
CHAR8 * GetBufAddrBaseOnOffset ( | |
IN UINT32 Offset | |
); | |
}; | |
extern CFormPkg gCFormPkg; | |
extern CVfrStringDB gCVfrStringDB; | |
extern UINT32 gAdjustOpcodeOffset; | |
extern BOOLEAN gNeedAdjustOpcode; | |
struct SIfrRecord { | |
UINT32 mLineNo; | |
CHAR8 *mIfrBinBuf; | |
UINT8 mBinBufLen; | |
UINT32 mOffset; | |
SIfrRecord *mNext; | |
SIfrRecord (VOID); | |
~SIfrRecord (VOID); | |
}; | |
#define EFI_IFR_RECORDINFO_IDX_INVALUD 0xFFFFFF | |
#define EFI_IFR_RECORDINFO_IDX_START 0x0 | |
#define EFI_HII_MAX_SUPPORT_DEFAULT_TYPE 0x08 | |
struct QuestionDefaultRecord { | |
BOOLEAN mIsDefaultIdExist[EFI_HII_MAX_SUPPORT_DEFAULT_TYPE]; // Record the default id in mAllDefaultIdArray[EFI_HII_MAX_SUPPORT_DEFAULT_TYPE] | |
// whether exists in current question. | |
SIfrRecord *mDefaultValueRecord; // Point to the default value record in RecordList which has smallest default Id. | |
// (for checkbox it may be NULL, because the dedault value is always true when the flag is set.) | |
BOOLEAN mIsDefaultOpcode; // whether the default value with smallest default id is given by default opcode. | |
// (for oneof and checkbox default info may be given by flag.) | |
UINT16 mDefaultNumber; // The default number of this question. | |
}; | |
class CIfrRecordInfoDB { | |
private: | |
bool mSwitch; | |
UINT32 mRecordCount; | |
SIfrRecord *mIfrRecordListHead; | |
SIfrRecord *mIfrRecordListTail; | |
UINT8 mAllDefaultTypeCount; | |
UINT16 mAllDefaultIdArray[EFI_HII_MAX_SUPPORT_DEFAULT_TYPE]; | |
SIfrRecord * GetRecordInfoFromIdx (IN UINT32); | |
BOOLEAN CheckQuestionOpCode (IN UINT8); | |
BOOLEAN CheckIdOpCode (IN UINT8); | |
EFI_QUESTION_ID GetOpcodeQuestionId (IN EFI_IFR_OP_HEADER *); | |
public: | |
CIfrRecordInfoDB (VOID); | |
~CIfrRecordInfoDB (VOID); | |
inline VOID TurnOn (VOID) { | |
mSwitch = TRUE; | |
} | |
inline VOID TurnOff (VOID) { | |
mSwitch = FALSE; | |
} | |
SIfrRecord * GetRecordInfoFromOffset (IN UINT32); | |
VOID IfrAdjustOffsetForRecord (VOID); | |
BOOLEAN IfrAdjustDynamicOpcodeInRecords (IN BOOLEAN); | |
UINT32 IfrRecordRegister (IN UINT32, IN CHAR8 *, IN UINT8, IN UINT32); | |
VOID IfrRecordInfoUpdate (IN UINT32, IN UINT32, IN CHAR8*, IN UINT8, IN UINT32); | |
VOID IfrRecordOutput (IN FILE *, IN UINT32 LineNo); | |
VOID IfrRecordOutput (OUT PACKAGE_DATA &); | |
EFI_VFR_RETURN_CODE IfrRecordAdjust (VOID); | |
VOID IfrUpdateRecordInfoForDynamicOpcode (IN BOOLEAN); | |
VOID IfrCheckAddDefaultRecord (IN BOOLEAN, IN BOOLEAN); | |
VOID IfrGetDefaultStoreInfo (); | |
VOID IfrCreateDefaultRecord (IN UINT8 Size,IN UINT16 DefaultId,IN UINT8 Type,IN UINT32 LineNo,IN EFI_IFR_TYPE_VALUE Value); | |
VOID IfrCreateDefaultForQuestion (IN SIfrRecord *, IN QuestionDefaultRecord *); | |
VOID IfrParseDefaulInfoInQuestion (IN SIfrRecord *, OUT QuestionDefaultRecord *); | |
VOID IfrAddDefaultToBufferConfig (IN UINT16, IN SIfrRecord *,IN EFI_IFR_TYPE_VALUE); | |
private: | |
CIfrRecordInfoDB (IN CONST CIfrRecordInfoDB&); // Prevent copy-construction | |
CIfrRecordInfoDB& operator= (IN CONST CIfrRecordInfoDB&); // Prevent assignment | |
}; | |
extern CIfrRecordInfoDB gCIfrRecordInfoDB; | |
/* | |
* The definition of CIfrObj | |
*/ | |
extern BOOLEAN gCreateOp; | |
class CIfrObj { | |
private: | |
BOOLEAN mDelayEmit; | |
CHAR8 *mObjBinBuf; | |
UINT8 mObjBinLen; | |
UINT32 mLineNo; | |
UINT32 mRecordIdx; | |
UINT32 mPkgOffset; | |
public: | |
CIfrObj (IN UINT8 OpCode, OUT CHAR8 **IfrObj = NULL, IN UINT8 ObjBinLen = 0, IN BOOLEAN DelayEmit = FALSE); | |
virtual ~CIfrObj(VOID); | |
VOID _EMIT_PENDING_OBJ (VOID); | |
inline VOID SetLineNo (IN UINT32 LineNo) { | |
mLineNo = LineNo; | |
} | |
template<typename T> | |
inline T * GetObjBinAddr (VOID) { | |
return reinterpret_cast<T *>(mObjBinBuf); | |
} | |
inline UINT32 GetObjBinOffset (VOID) { | |
return mPkgOffset; | |
} | |
inline UINT8 GetObjBinLen (VOID) { | |
return mObjBinLen; | |
} | |
inline bool ExpendObjBin (IN UINT8 Size) { | |
if ((mDelayEmit == TRUE) && ((mObjBinLen + Size) > mObjBinLen)) { | |
mObjBinLen = mObjBinLen + Size; | |
return TRUE; | |
} else { | |
return FALSE; | |
} | |
} | |
inline bool ShrinkObjBin (IN UINT8 Size) { | |
if ((mDelayEmit == TRUE) && (mObjBinLen > Size)) { | |
mObjBinLen -= Size; | |
return TRUE; | |
} else { | |
return FALSE; | |
} | |
} | |
}; | |
/* | |
* The definition of CIfrOpHeader | |
*/ | |
class CIfrOpHeader { | |
private: | |
EFI_IFR_OP_HEADER *mHeader; | |
public: | |
CIfrOpHeader (IN UINT8 OpCode, IN VOID *StartAddr, IN UINT8 Length = 0); | |
CIfrOpHeader (IN CIfrOpHeader &); | |
CIfrOpHeader& operator=(IN CONST CIfrOpHeader &); | |
VOID IncLength (UINT8 Size) { | |
if ((mHeader->Length + Size) > mHeader->Length) { | |
mHeader->Length = mHeader->Length + Size; | |
} | |
} | |
VOID DecLength (UINT8 Size) { | |
if (mHeader->Length >= Size) { | |
mHeader->Length -= Size; | |
} | |
} | |
UINT8 GetLength () { | |
return mHeader->Length; | |
} | |
UINT8 GetScope () { | |
return mHeader->Scope; | |
} | |
VOID SetScope (IN UINT8 Scope) { | |
mHeader->Scope = Scope; | |
} | |
VOID UpdateHeader (IN EFI_IFR_OP_HEADER *Header) { | |
mHeader = Header; | |
} | |
UINT8 GetOpCode () { | |
return mHeader->OpCode; | |
} | |
}; | |
extern UINT8 gScopeCount; | |
/* | |
* The definition of CIfrStatementHeader | |
*/ | |
class CIfrStatementHeader { | |
private: | |
EFI_IFR_STATEMENT_HEADER *mHeader; | |
public: | |
CIfrStatementHeader ( | |
IN EFI_IFR_STATEMENT_HEADER *StartAddr | |
) : mHeader ((EFI_IFR_STATEMENT_HEADER *)StartAddr) { | |
mHeader = StartAddr; | |
mHeader->Help = EFI_STRING_ID_INVALID; | |
mHeader->Prompt = EFI_STRING_ID_INVALID; | |
} | |
EFI_IFR_STATEMENT_HEADER *GetStatementHeader () { | |
return mHeader; | |
} | |
VOID SetPrompt (IN EFI_STRING_ID Prompt) { | |
mHeader->Prompt = Prompt; | |
} | |
VOID SetHelp (IN EFI_STRING_ID Help) { | |
mHeader->Help = Help; | |
} | |
}; | |
/* | |
* The definition of CIfrQuestionHeader | |
*/ | |
#define EFI_IFR_QUESTION_FLAG_DEFAULT 0 | |
class CIfrQuestionHeader : public CIfrStatementHeader { | |
private: | |
EFI_IFR_QUESTION_HEADER *mHeader; | |
EFI_IFR_STATEMENT_HEADER * QH2SH (EFI_IFR_QUESTION_HEADER *Qheader) { | |
return &(Qheader)->Header; | |
} | |
public: | |
EFI_QUESTION_ID QUESTION_ID (VOID) { | |
return mHeader->QuestionId; | |
} | |
EFI_VARSTORE_ID VARSTORE_ID (VOID) { | |
return mHeader->VarStoreId; | |
} | |
VOID VARSTORE_INFO (OUT EFI_VARSTORE_INFO *Info) { | |
if (Info != NULL) { | |
Info->mVarStoreId = mHeader->VarStoreId; | |
memmove (&Info->mVarStoreId, &mHeader->VarStoreInfo, sizeof (Info->mVarStoreId)); | |
} | |
} | |
UINT8 FLAGS (VOID) { | |
return mHeader->Flags; | |
} | |
public: | |
CIfrQuestionHeader ( | |
IN EFI_IFR_QUESTION_HEADER *StartAddr, | |
IN UINT8 Flags = EFI_IFR_QUESTION_FLAG_DEFAULT | |
) : CIfrStatementHeader (QH2SH(StartAddr)) { | |
mHeader = StartAddr; | |
mHeader->QuestionId = EFI_QUESTION_ID_INVALID; | |
mHeader->VarStoreId = EFI_VARSTORE_ID_INVALID; | |
mHeader->VarStoreInfo.VarName = EFI_STRING_ID_INVALID; | |
mHeader->VarStoreInfo.VarOffset = EFI_VAROFFSET_INVALID; | |
mHeader->Flags = Flags; | |
} | |
VOID SetQuestionId (IN EFI_QUESTION_ID QuestionId) { | |
mHeader->QuestionId = QuestionId; | |
} | |
VOID SetVarStoreInfo (IN EFI_VARSTORE_INFO *Info) { | |
mHeader->VarStoreId = Info->mVarStoreId; | |
mHeader->VarStoreInfo.VarName = Info->mInfo.mVarName; | |
mHeader->VarStoreInfo.VarOffset = Info->mInfo.mVarOffset; | |
} | |
EFI_VFR_RETURN_CODE SetFlags (IN UINT8 Flags) { | |
if (_FLAG_TEST_AND_CLEAR (Flags, EFI_IFR_FLAG_READ_ONLY)) { | |
mHeader->Flags |= EFI_IFR_FLAG_READ_ONLY; | |
} | |
_FLAG_CLEAR (Flags, 0x02); | |
if (_FLAG_TEST_AND_CLEAR (Flags, EFI_IFR_FLAG_CALLBACK)) { | |
mHeader->Flags |= EFI_IFR_FLAG_CALLBACK; | |
} | |
// | |
// ignore NVAccessFlag | |
// | |
_FLAG_CLEAR (Flags, 0x08); | |
if (_FLAG_TEST_AND_CLEAR (Flags, EFI_IFR_FLAG_RESET_REQUIRED)) { | |
mHeader->Flags |= EFI_IFR_FLAG_RESET_REQUIRED; | |
} | |
if (_FLAG_TEST_AND_CLEAR (Flags, EFI_IFR_FLAG_RECONNECT_REQUIRED)) { | |
mHeader->Flags |= EFI_IFR_FLAG_RECONNECT_REQUIRED; | |
} | |
// | |
// Set LateCheck Flag to compatible for framework flag | |
// but it uses 0x20 as its flag, if in the future UEFI may take this flag | |
// | |
if (_FLAG_TEST_AND_CLEAR (Flags, 0x20)) { | |
mHeader->Flags |= 0x20; | |
} | |
if (_FLAG_TEST_AND_CLEAR (Flags, EFI_IFR_FLAG_OPTIONS_ONLY)) { | |
mHeader->Flags |= EFI_IFR_FLAG_OPTIONS_ONLY; | |
} | |
return _FLAGS_ZERO (Flags) ? VFR_RETURN_SUCCESS : VFR_RETURN_FLAGS_UNSUPPORTED; | |
} | |
VOID UpdateCIfrQuestionHeader (IN EFI_IFR_QUESTION_HEADER *Header) { | |
mHeader = Header; | |
} | |
}; | |
/* | |
* The definition of CIfrMinMaxStepData | |
*/ | |
class CIfrMinMaxStepData { | |
private: | |
MINMAXSTEP_DATA *mMinMaxStepData; | |
BOOLEAN ValueIsSet; | |
BOOLEAN IsNumeric; | |
public: | |
CIfrMinMaxStepData (MINMAXSTEP_DATA *DataAddr, BOOLEAN NumericOpcode=FALSE) : mMinMaxStepData (DataAddr) { | |
mMinMaxStepData->u64.MinValue = 0; | |
mMinMaxStepData->u64.MaxValue = 0; | |
mMinMaxStepData->u64.Step = 0; | |
ValueIsSet = FALSE; | |
IsNumeric = NumericOpcode; | |
} | |
VOID SetMinMaxStepData (IN UINT64 MinValue, IN UINT64 MaxValue, IN UINT64 Step) { | |
if (!ValueIsSet) { | |
mMinMaxStepData->u64.MinValue = MinValue; | |
mMinMaxStepData->u64.MaxValue = MaxValue; | |
ValueIsSet = TRUE; | |
} else { | |
if (MinValue < mMinMaxStepData->u64.MinValue) { | |
mMinMaxStepData->u64.MinValue = MinValue; | |
} | |
if (MaxValue > mMinMaxStepData->u64.MaxValue) { | |
mMinMaxStepData->u64.MaxValue = MaxValue; | |
} | |
} | |
mMinMaxStepData->u64.Step = Step; | |
} | |
VOID SetMinMaxStepData (IN UINT32 MinValue, IN UINT32 MaxValue, IN UINT32 Step) { | |
if (!ValueIsSet) { | |
mMinMaxStepData->u32.MinValue = MinValue; | |
mMinMaxStepData->u32.MaxValue = MaxValue; | |
ValueIsSet = TRUE; | |
} else { | |
if (MinValue < mMinMaxStepData->u32.MinValue) { | |
mMinMaxStepData->u32.MinValue = MinValue; | |
} | |
if (MaxValue > mMinMaxStepData->u32.MaxValue) { | |
mMinMaxStepData->u32.MaxValue = MaxValue; | |
} | |
} | |
mMinMaxStepData->u32.Step = Step; | |
} | |
VOID SetMinMaxStepData (IN UINT16 MinValue, IN UINT16 MaxValue, IN UINT16 Step) { | |
if (!ValueIsSet) { | |
mMinMaxStepData->u16.MinValue = MinValue; | |
mMinMaxStepData->u16.MaxValue = MaxValue; | |
ValueIsSet = TRUE; | |
} else { | |
if (MinValue < mMinMaxStepData->u16.MinValue) { | |
mMinMaxStepData->u16.MinValue = MinValue; | |
} | |
if (MaxValue > mMinMaxStepData->u16.MaxValue) { | |
mMinMaxStepData->u16.MaxValue = MaxValue; | |
} | |
} | |
mMinMaxStepData->u16.Step = Step; | |
} | |
VOID SetMinMaxStepData (IN UINT8 MinValue, IN UINT8 MaxValue, IN UINT8 Step) { | |
if (!ValueIsSet) { | |
mMinMaxStepData->u8.MinValue = MinValue; | |
mMinMaxStepData->u8.MaxValue = MaxValue; | |
ValueIsSet = TRUE; | |
} else { | |
if (MinValue < mMinMaxStepData->u8.MinValue) { | |
mMinMaxStepData->u8.MinValue = MinValue; | |
} | |
if (MaxValue > mMinMaxStepData->u8.MaxValue) { | |
mMinMaxStepData->u8.MaxValue = MaxValue; | |
} | |
} | |
mMinMaxStepData->u8.Step = Step; | |
} | |
UINT64 GetMinData (UINT8 VarType, BOOLEAN IsBitVar) { | |
UINT64 MinValue = 0; | |
if (IsBitVar) { | |
MinValue = mMinMaxStepData->u32.MinValue; | |
return MinValue; | |
} | |
switch (VarType) { | |
case EFI_IFR_TYPE_NUM_SIZE_64: | |
MinValue = mMinMaxStepData->u64.MinValue; | |
break; | |
case EFI_IFR_TYPE_NUM_SIZE_32: | |
MinValue = (UINT64) mMinMaxStepData->u32.MinValue; | |
break; | |
case EFI_IFR_TYPE_NUM_SIZE_16: | |
MinValue = (UINT64) mMinMaxStepData->u16.MinValue; | |
break; | |
case EFI_IFR_TYPE_NUM_SIZE_8: | |
MinValue = (UINT64) mMinMaxStepData->u8.MinValue; | |
break; | |
default: | |
break; | |
} | |
return MinValue; | |
} | |
UINT64 GetMaxData (UINT8 VarType, BOOLEAN IsBitVar) { | |
UINT64 MaxValue = 0; | |
if (IsBitVar) { | |
MaxValue = mMinMaxStepData->u32.MaxValue; | |
return MaxValue; | |
} | |
switch (VarType) { | |
case EFI_IFR_TYPE_NUM_SIZE_64: | |
MaxValue = mMinMaxStepData->u64.MaxValue; | |
break; | |
case EFI_IFR_TYPE_NUM_SIZE_32: | |
MaxValue = (UINT64) mMinMaxStepData->u32.MaxValue; | |
break; | |
case EFI_IFR_TYPE_NUM_SIZE_16: | |
MaxValue = (UINT64) mMinMaxStepData->u16.MaxValue; | |
break; | |
case EFI_IFR_TYPE_NUM_SIZE_8: | |
MaxValue = (UINT64) mMinMaxStepData->u8.MaxValue; | |
break; | |
default: | |
break; | |
} | |
return MaxValue; | |
} | |
UINT64 GetStepData (UINT8 VarType, BOOLEAN IsBitVar) { | |
UINT64 MaxValue = 0; | |
if (IsBitVar) { | |
MaxValue = mMinMaxStepData->u32.Step; | |
return MaxValue; | |
} | |
switch (VarType) { | |
case EFI_IFR_TYPE_NUM_SIZE_64: | |
MaxValue = mMinMaxStepData->u64.Step; | |
break; | |
case EFI_IFR_TYPE_NUM_SIZE_32: | |
MaxValue = (UINT64) mMinMaxStepData->u32.Step; | |
break; | |
case EFI_IFR_TYPE_NUM_SIZE_16: | |
MaxValue = (UINT64) mMinMaxStepData->u16.Step; | |
break; | |
case EFI_IFR_TYPE_NUM_SIZE_8: | |
MaxValue = (UINT64) mMinMaxStepData->u8.Step; | |
break; | |
default: | |
break; | |
} | |
return MaxValue; | |
} | |
BOOLEAN IsNumericOpcode () { | |
return IsNumeric; | |
} | |
VOID UpdateCIfrMinMaxStepData (IN MINMAXSTEP_DATA *MinMaxStepData) { | |
mMinMaxStepData = MinMaxStepData; | |
} | |
}; | |
static CIfrQuestionHeader *gCurrentQuestion = NULL; | |
static CIfrMinMaxStepData *gCurrentMinMaxData = NULL; | |
static BOOLEAN gIsOrderedList = FALSE; | |
static BOOLEAN gIsStringOp = FALSE; | |
/* | |
* The definition of all of the UEFI IFR Objects | |
*/ | |
class CIfrFormSet : public CIfrObj, public CIfrOpHeader { | |
private: | |
EFI_IFR_FORM_SET *mFormSet; | |
EFI_GUID *mClassGuid; | |
public: | |
CIfrFormSet (UINT8 Size) : CIfrObj (EFI_IFR_FORM_SET_OP, (CHAR8 **)NULL, Size), | |
CIfrOpHeader (EFI_IFR_FORM_SET_OP, &(GetObjBinAddr<EFI_IFR_FORM_SET>())->Header, Size), mFormSet(GetObjBinAddr<EFI_IFR_FORM_SET>()) { | |
mFormSet->Help = EFI_STRING_ID_INVALID; | |
mFormSet->FormSetTitle = EFI_STRING_ID_INVALID; | |
mFormSet->Flags = 0; | |
memset (&mFormSet->Guid, 0, sizeof (EFI_GUID)); | |
mClassGuid = (EFI_GUID *) (mFormSet + 1); | |
} | |
VOID SetGuid (IN EFI_GUID *Guid) { | |
memmove (&mFormSet->Guid, Guid, sizeof (EFI_GUID)); | |
} | |
VOID SetFormSetTitle (IN EFI_STRING_ID FormSetTitle) { | |
mFormSet->FormSetTitle = FormSetTitle; | |
} | |
VOID SetHelp (IN EFI_STRING_ID Help) { | |
mFormSet->Help = Help; | |
} | |
VOID SetClassGuid (IN EFI_GUID *Guid) { | |
memmove (&(mClassGuid[mFormSet->Flags++]), Guid, sizeof (EFI_GUID)); | |
} | |
UINT8 GetFlags() { | |
return mFormSet->Flags; | |
} | |
}; | |
class CIfrEnd : public CIfrObj, public CIfrOpHeader { | |
public: | |
CIfrEnd () : CIfrObj (EFI_IFR_END_OP), | |
CIfrOpHeader (EFI_IFR_END_OP, &(GetObjBinAddr<EFI_IFR_END>())->Header) {} | |
}; | |
class CIfrDefaultStore : public CIfrObj, public CIfrOpHeader { | |
private: | |
EFI_IFR_DEFAULTSTORE *mDefaultStore; | |
public: | |
CIfrDefaultStore () : CIfrObj (EFI_IFR_DEFAULTSTORE_OP), | |
CIfrOpHeader (EFI_IFR_DEFAULTSTORE_OP, &(GetObjBinAddr<EFI_IFR_DEFAULTSTORE>())->Header), mDefaultStore(GetObjBinAddr<EFI_IFR_DEFAULTSTORE>()) { | |
mDefaultStore->DefaultId = EFI_VARSTORE_ID_INVALID; | |
mDefaultStore->DefaultName = EFI_STRING_ID_INVALID; | |
} | |
VOID SetDefaultName (IN EFI_STRING_ID DefaultName) { | |
mDefaultStore->DefaultName = DefaultName; | |
} | |
VOID SetDefaultId (IN UINT16 DefaultId) { | |
mDefaultStore->DefaultId = DefaultId; | |
} | |
}; | |
#define EFI_FORM_ID_MAX 0xFFFF | |
#define EFI_FREE_FORM_ID_BITMAP_SIZE ((EFI_FORM_ID_MAX + 1) / EFI_BITS_PER_UINT32) | |
class CIfrFormId { | |
public: | |
STATIC UINT32 FormIdBitMap[EFI_FREE_FORM_ID_BITMAP_SIZE]; | |
STATIC BOOLEAN ChekFormIdFree (IN EFI_FORM_ID FormId) { | |
UINT32 Index = (FormId / EFI_BITS_PER_UINT32); | |
UINT32 Offset = (FormId % EFI_BITS_PER_UINT32); | |
return (FormIdBitMap[Index] & (0x80000000 >> Offset)) == 0; | |
} | |
STATIC VOID MarkFormIdUsed (IN EFI_FORM_ID FormId) { | |
UINT32 Index = (FormId / EFI_BITS_PER_UINT32); | |
UINT32 Offset = (FormId % EFI_BITS_PER_UINT32); | |
FormIdBitMap[Index] |= (0x80000000 >> Offset); | |
} | |
}; | |
class CIfrForm : public CIfrObj, public CIfrOpHeader { | |
private: | |
EFI_IFR_FORM *mForm; | |
public: | |
CIfrForm () : CIfrObj (EFI_IFR_FORM_OP), | |
CIfrOpHeader (EFI_IFR_FORM_OP, &(GetObjBinAddr<EFI_IFR_FORM>())->Header), mForm(GetObjBinAddr<EFI_IFR_FORM>()) { | |
mForm->FormId = 0; | |
mForm->FormTitle = EFI_STRING_ID_INVALID; | |
} | |
EFI_VFR_RETURN_CODE SetFormId (IN EFI_FORM_ID FormId) { | |
if (FormId == 0) { | |
// | |
// FormId can't be 0. | |
// | |
return VFR_RETURN_INVALID_PARAMETER; | |
} | |
if (CIfrFormId::ChekFormIdFree (FormId) == FALSE) { | |
return VFR_RETURN_FORMID_REDEFINED; | |
} | |
mForm->FormId = FormId; | |
CIfrFormId::MarkFormIdUsed (FormId); | |
return VFR_RETURN_SUCCESS; | |
} | |
VOID SetFormTitle (IN EFI_STRING_ID FormTitle) { | |
mForm->FormTitle = FormTitle; | |
} | |
}; | |
class CIfrFormMap : public CIfrObj, public CIfrOpHeader { | |
private: | |
EFI_IFR_FORM_MAP *mFormMap; | |
EFI_IFR_FORM_MAP_METHOD *mMethodMap; | |
public: | |
CIfrFormMap () : CIfrObj (EFI_IFR_FORM_MAP_OP, (CHAR8 **)NULL, sizeof (EFI_IFR_FORM_MAP), TRUE), | |
CIfrOpHeader (EFI_IFR_FORM_MAP_OP, &(GetObjBinAddr<EFI_IFR_FORM_MAP>())->Header), mFormMap(GetObjBinAddr<EFI_IFR_FORM_MAP>()) { | |
mFormMap->FormId = 0; | |
mMethodMap = (EFI_IFR_FORM_MAP_METHOD *) (mFormMap + 1); | |
} | |
EFI_VFR_RETURN_CODE SetFormId (IN EFI_FORM_ID FormId) { | |
if (FormId == 0) { | |
// | |
// FormId can't be 0. | |
// | |
return VFR_RETURN_INVALID_PARAMETER; | |
} | |
if (CIfrFormId::ChekFormIdFree (FormId) == FALSE) { | |
return VFR_RETURN_FORMID_REDEFINED; | |
} | |
mFormMap->FormId = FormId; | |
CIfrFormId::MarkFormIdUsed (FormId); | |
return VFR_RETURN_SUCCESS; | |
} | |
VOID SetFormMapMethod (IN EFI_STRING_ID MethodTitle, IN EFI_GUID *MethodGuid) { | |
if (ExpendObjBin (sizeof (EFI_IFR_FORM_MAP_METHOD))) { | |
IncLength (sizeof (EFI_IFR_FORM_MAP_METHOD)); | |
mMethodMap->MethodTitle = MethodTitle; | |
memmove (&(mMethodMap->MethodIdentifier), MethodGuid, sizeof (EFI_GUID)); | |
mMethodMap ++; | |
} | |
} | |
}; | |
class CIfrVarStore : public CIfrObj, public CIfrOpHeader { | |
private: | |
EFI_IFR_VARSTORE *mVarStore; | |
public: | |
CIfrVarStore () : CIfrObj (EFI_IFR_VARSTORE_OP, (CHAR8 **)NULL, sizeof (EFI_IFR_VARSTORE), TRUE), | |
CIfrOpHeader (EFI_IFR_VARSTORE_OP, &(GetObjBinAddr<EFI_IFR_VARSTORE>())->Header), mVarStore(GetObjBinAddr<EFI_IFR_VARSTORE>()) { | |
mVarStore->VarStoreId = EFI_VARSTORE_ID_INVALID; | |
mVarStore->Size = 0; | |
memset (&mVarStore->Guid, 0, sizeof (EFI_GUID)); | |
mVarStore->Name[0] = '\0'; | |
} | |
VOID SetGuid (IN EFI_GUID *Guid) { | |
memmove (&mVarStore->Guid, Guid, sizeof (EFI_GUID)); | |
} | |
VOID SetVarStoreId (IN EFI_VARSTORE_ID VarStoreId) { | |
mVarStore->VarStoreId = VarStoreId; | |
} | |
VOID SetSize (IN UINT16 Size) { | |
mVarStore->Size = Size; | |
} | |
VOID SetName (IN CHAR8 *Name) { | |
UINT8 Len; | |
if (Name != NULL) { | |
Len = (UINT8) strlen (Name); | |
if (Len != 0) { | |
if (ExpendObjBin (Len) == TRUE) { | |
IncLength (Len); | |
strcpy ((CHAR8 *)(mVarStore->Name), Name); | |
} | |
} | |
} | |
} | |
}; | |
class CIfrVarStoreEfi : public CIfrObj, public CIfrOpHeader { | |
private: | |
EFI_IFR_VARSTORE_EFI *mVarStoreEfi; | |
public: | |
CIfrVarStoreEfi () : CIfrObj (EFI_IFR_VARSTORE_EFI_OP, (CHAR8 **)NULL, sizeof (EFI_IFR_VARSTORE_EFI), TRUE), | |
CIfrOpHeader (EFI_IFR_VARSTORE_EFI_OP, &(GetObjBinAddr<EFI_IFR_VARSTORE_EFI>())->Header), mVarStoreEfi(GetObjBinAddr<EFI_IFR_VARSTORE_EFI>()) { | |
mVarStoreEfi->VarStoreId = EFI_VAROFFSET_INVALID; | |
mVarStoreEfi->Size = 0; | |
memset (&mVarStoreEfi->Guid, 0, sizeof (EFI_GUID)); | |
mVarStoreEfi->Name[0] = '\0'; | |
} | |
VOID SetGuid (IN EFI_GUID *Guid) { | |
memmove (&mVarStoreEfi->Guid, Guid, sizeof (EFI_GUID)); | |
} | |
VOID SetVarStoreId (IN UINT16 VarStoreId) { | |
mVarStoreEfi->VarStoreId = VarStoreId; | |
} | |
VOID SetAttributes (IN UINT32 Attributes) { | |
mVarStoreEfi->Attributes = Attributes; | |
} | |
VOID SetSize (IN UINT16 Size) { | |
mVarStoreEfi->Size = Size; | |
} | |
VOID SetName (IN CHAR8 *Name) { | |
UINT8 Len; | |
if (Name != NULL) { | |
Len = (UINT8) strlen (Name); | |
if (Len != 0) { | |
if (ExpendObjBin (Len) == TRUE) { | |
IncLength (Len); | |
strcpy ((CHAR8 *)(mVarStoreEfi->Name), Name); | |
} | |
} | |
} | |
} | |
VOID SetBinaryLength (IN UINT16 Size) { | |
UINT16 Len; | |
Len = sizeof (EFI_IFR_VARSTORE_EFI); | |
if (Size > Len) { | |
ExpendObjBin(Size - Len); | |
IncLength(Size - Len); | |
} else { | |
ShrinkObjBin(Len - Size); | |
DecLength(Len - Size); | |
} | |
} | |
}; | |
class CIfrVarStoreNameValue : public CIfrObj, public CIfrOpHeader { | |
private: | |
EFI_IFR_VARSTORE_NAME_VALUE *mVarStoreNameValue; | |
public: | |
CIfrVarStoreNameValue () : CIfrObj (EFI_IFR_VARSTORE_NAME_VALUE_OP), | |
CIfrOpHeader (EFI_IFR_VARSTORE_NAME_VALUE_OP, &(GetObjBinAddr<EFI_IFR_VARSTORE_NAME_VALUE>())->Header), mVarStoreNameValue(GetObjBinAddr<EFI_IFR_VARSTORE_NAME_VALUE>()) { | |
mVarStoreNameValue->VarStoreId = EFI_VAROFFSET_INVALID; | |
memset (&mVarStoreNameValue->Guid, 0, sizeof (EFI_GUID)); | |
} | |
VOID SetGuid (IN EFI_GUID *Guid) { | |
memmove (&mVarStoreNameValue->Guid, Guid, sizeof (EFI_GUID)); | |
} | |
VOID SetVarStoreId (IN UINT16 VarStoreId) { | |
mVarStoreNameValue->VarStoreId = VarStoreId; | |
} | |
}; | |
class CIfrImage : public CIfrObj, public CIfrOpHeader { | |
private: | |
EFI_IFR_IMAGE *mImage; | |
public: | |
CIfrImage () : CIfrObj (EFI_IFR_IMAGE_OP), | |
CIfrOpHeader (EFI_IFR_IMAGE_OP, &(GetObjBinAddr<EFI_IFR_IMAGE>())->Header), mImage(GetObjBinAddr<EFI_IFR_IMAGE>()) { | |
mImage->Id = EFI_IMAGE_ID_INVALID; | |
} | |
VOID SetImageId (IN EFI_IMAGE_ID ImageId) { | |
mImage->Id = ImageId; | |
} | |
}; | |
class CIfrModal : public CIfrObj, public CIfrOpHeader { | |
public: | |
CIfrModal () : CIfrObj (EFI_IFR_MODAL_TAG_OP), | |
CIfrOpHeader (EFI_IFR_MODAL_TAG_OP, &(GetObjBinAddr<EFI_IFR_MODAL_TAG>())->Header) { | |
} | |
}; | |
class CIfrLocked : public CIfrObj, public CIfrOpHeader { | |
public: | |
CIfrLocked () : CIfrObj (EFI_IFR_LOCKED_OP), | |
CIfrOpHeader (EFI_IFR_LOCKED_OP, &(GetObjBinAddr<EFI_IFR_LOCKED>())->Header) {} | |
}; | |
class CIfrRule : public CIfrObj, public CIfrOpHeader { | |
private: | |
EFI_IFR_RULE *mRule; | |
public: | |
CIfrRule () : CIfrObj (EFI_IFR_RULE_OP), | |
CIfrOpHeader (EFI_IFR_RULE_OP, &(GetObjBinAddr<EFI_IFR_RULE>())->Header), mRule(GetObjBinAddr<EFI_IFR_RULE>()) { | |
mRule->RuleId = EFI_RULE_ID_INVALID; | |
} | |
VOID SetRuleId (IN UINT8 RuleId) { | |
mRule->RuleId = RuleId; | |
} | |
}; | |
static EFI_IFR_TYPE_VALUE gZeroEfiIfrTypeValue = {0, }; | |
class CIfrDefault : public CIfrObj, public CIfrOpHeader { | |
private: | |
EFI_IFR_DEFAULT *mDefault; | |
public: | |
CIfrDefault ( | |
IN UINT8 Size, | |
IN UINT16 DefaultId = EFI_HII_DEFAULT_CLASS_STANDARD, | |
IN UINT8 Type = EFI_IFR_TYPE_OTHER, | |
IN EFI_IFR_TYPE_VALUE Value = gZeroEfiIfrTypeValue | |
) : CIfrObj (EFI_IFR_DEFAULT_OP, (CHAR8 **)NULL, Size), | |
CIfrOpHeader (EFI_IFR_DEFAULT_OP, &(GetObjBinAddr<EFI_IFR_DEFAULT>())->Header, Size), mDefault(GetObjBinAddr<EFI_IFR_DEFAULT>()) { | |
mDefault->Type = Type; | |
mDefault->DefaultId = DefaultId; | |
memmove (&(mDefault->Value), &Value, Size - OFFSET_OF (EFI_IFR_DEFAULT, Value)); | |
} | |
VOID SetDefaultId (IN UINT16 DefaultId) { | |
mDefault->DefaultId = DefaultId; | |
} | |
VOID SetType (IN UINT8 Type) { | |
mDefault->Type = Type; | |
} | |
VOID SetValue (IN EFI_IFR_TYPE_VALUE Value) { | |
memmove (&mDefault->Value, &Value, mDefault->Header.Length - OFFSET_OF (EFI_IFR_DEFAULT, Value)); | |
} | |
}; | |
class CIfrDefault2 : public CIfrObj, public CIfrOpHeader { | |
private: | |
EFI_IFR_DEFAULT_2 *mDefault; | |
public: | |
CIfrDefault2 ( | |
IN UINT16 DefaultId = EFI_HII_DEFAULT_CLASS_STANDARD, | |
IN UINT8 Type = EFI_IFR_TYPE_OTHER | |
) : CIfrObj (EFI_IFR_DEFAULT_OP, (CHAR8 **)NULL, sizeof (EFI_IFR_DEFAULT_2)), | |
CIfrOpHeader (EFI_IFR_DEFAULT_OP, &(GetObjBinAddr<EFI_IFR_DEFAULT_2>())->Header, sizeof (EFI_IFR_DEFAULT_2)), mDefault(GetObjBinAddr<EFI_IFR_DEFAULT_2>()) { | |
mDefault->Type = Type; | |
mDefault->DefaultId = DefaultId; | |
} | |
VOID SetDefaultId (IN UINT16 DefaultId) { | |
mDefault->DefaultId = DefaultId; | |
} | |
VOID SetType (IN UINT8 Type) { | |
mDefault->Type = Type; | |
} | |
}; | |
class CIfrValue : public CIfrObj, public CIfrOpHeader{ | |
public: | |
CIfrValue () : CIfrObj (EFI_IFR_VALUE_OP), | |
CIfrOpHeader (EFI_IFR_VALUE_OP, &(GetObjBinAddr<EFI_IFR_VALUE>())->Header) {} | |
}; | |
class CIfrRead : public CIfrObj, public CIfrOpHeader{ | |
public: | |
CIfrRead () : CIfrObj (EFI_IFR_READ_OP), | |
CIfrOpHeader (EFI_IFR_READ_OP, &(GetObjBinAddr<EFI_IFR_READ>())->Header) {} | |
}; | |
class CIfrWrite : public CIfrObj, public CIfrOpHeader{ | |
public: | |
CIfrWrite () : CIfrObj (EFI_IFR_WRITE_OP), | |
CIfrOpHeader (EFI_IFR_WRITE_OP, &(GetObjBinAddr<EFI_IFR_WRITE>())->Header) {} | |
}; | |
class CIfrGet : public CIfrObj, public CIfrOpHeader{ | |
private: | |
EFI_IFR_GET *mGet; | |
public: | |
CIfrGet ( | |
IN UINT32 LineNo | |
) : CIfrObj (EFI_IFR_GET_OP), | |
CIfrOpHeader (EFI_IFR_GET_OP, &(GetObjBinAddr<EFI_IFR_GET>())->Header), mGet(GetObjBinAddr<EFI_IFR_GET>()) { | |
SetLineNo (LineNo); | |
} | |
VOID SetVarInfo (IN EFI_VARSTORE_INFO *Info) { | |
mGet->VarStoreId = Info->mVarStoreId; | |
mGet->VarStoreInfo.VarName = Info->mInfo.mVarName; | |
mGet->VarStoreInfo.VarOffset = Info->mInfo.mVarOffset; | |
mGet->VarStoreType = Info->mVarType; | |
} | |
}; | |
class CIfrSet : public CIfrObj, public CIfrOpHeader{ | |
private: | |
EFI_IFR_SET *mSet; | |
public: | |
CIfrSet ( | |
IN UINT32 LineNo | |
) : CIfrObj (EFI_IFR_SET_OP), | |
CIfrOpHeader (EFI_IFR_SET_OP, &(GetObjBinAddr<EFI_IFR_SET>())->Header), mSet(GetObjBinAddr<EFI_IFR_SET>()) { | |
SetLineNo (LineNo); | |
} | |
VOID SetVarInfo (IN EFI_VARSTORE_INFO *Info) { | |
mSet->VarStoreId = Info->mVarStoreId; | |
mSet->VarStoreInfo.VarName = Info->mInfo.mVarName; | |
mSet->VarStoreInfo.VarOffset = Info->mInfo.mVarOffset; | |
mSet->VarStoreType = Info->mVarType; | |
} | |
}; | |
class CIfrSubtitle : public CIfrObj, public CIfrOpHeader, public CIfrStatementHeader { | |
private: | |
EFI_IFR_SUBTITLE *mSubtitle; | |
public: | |
CIfrSubtitle () : CIfrObj (EFI_IFR_SUBTITLE_OP), | |
CIfrOpHeader (EFI_IFR_SUBTITLE_OP, &(GetObjBinAddr<EFI_IFR_SUBTITLE>())->Header), | |
CIfrStatementHeader (&(GetObjBinAddr<EFI_IFR_SUBTITLE>())->Statement), mSubtitle(GetObjBinAddr<EFI_IFR_SUBTITLE>()) { | |
mSubtitle->Flags = 0; | |
} | |
EFI_VFR_RETURN_CODE SetFlags (IN UINT8 LFlags) { | |
if (_FLAG_TEST_AND_CLEAR (LFlags, EFI_IFR_FLAGS_HORIZONTAL)) { | |
mSubtitle->Flags |= EFI_IFR_FLAGS_HORIZONTAL; | |
} | |
return _FLAGS_ZERO (LFlags) ? VFR_RETURN_SUCCESS : VFR_RETURN_FLAGS_UNSUPPORTED; | |
} | |
}; | |
class CIfrText : public CIfrObj, public CIfrOpHeader, public CIfrStatementHeader { | |
private: | |
EFI_IFR_TEXT *mText; | |
public: | |
CIfrText () : CIfrObj (EFI_IFR_TEXT_OP), | |
CIfrOpHeader (EFI_IFR_TEXT_OP, &(GetObjBinAddr<EFI_IFR_TEXT>())->Header), | |
CIfrStatementHeader (&(GetObjBinAddr<EFI_IFR_TEXT>())->Statement), mText(GetObjBinAddr<EFI_IFR_TEXT>()) { | |
mText->TextTwo = EFI_STRING_ID_INVALID; | |
} | |
VOID SetTextTwo (IN EFI_STRING_ID StringId) { | |
mText->TextTwo = StringId; | |
} | |
}; | |
class CIfrRef : public CIfrObj, public CIfrOpHeader, public CIfrQuestionHeader { | |
private: | |
EFI_IFR_REF *mRef; | |
public: | |
CIfrRef () : CIfrObj (EFI_IFR_REF_OP), | |
CIfrOpHeader (EFI_IFR_REF_OP, &(GetObjBinAddr<EFI_IFR_REF>())->Header), | |
CIfrQuestionHeader (&(GetObjBinAddr<EFI_IFR_REF>())->Question), mRef(GetObjBinAddr<EFI_IFR_REF>()) { | |
mRef->FormId = 0; | |
} | |
VOID SetFormId (IN EFI_FORM_ID FormId) { | |
mRef->FormId = FormId; | |
} | |
}; | |
class CIfrRef2 : public CIfrObj, public CIfrOpHeader, public CIfrQuestionHeader { | |
private: | |
EFI_IFR_REF2 *mRef2; | |
public: | |
CIfrRef2 () : CIfrObj (EFI_IFR_REF_OP, (CHAR8 **)NULL, sizeof (EFI_IFR_REF2)), | |
CIfrOpHeader (EFI_IFR_REF_OP, &(GetObjBinAddr<EFI_IFR_REF2>())->Header, sizeof (EFI_IFR_REF2)), | |
CIfrQuestionHeader (&(GetObjBinAddr<EFI_IFR_REF2>())->Question), mRef2(GetObjBinAddr<EFI_IFR_REF2>()) { | |
mRef2->FormId = 0; | |
mRef2->QuestionId = EFI_QUESTION_ID_INVALID; | |
} | |
VOID SetFormId (IN EFI_FORM_ID FormId) { | |
mRef2->FormId = FormId; | |
} | |
VOID SetQuestionId (IN EFI_QUESTION_ID QuestionId) { | |
mRef2->QuestionId = QuestionId; | |
} | |
}; | |
class CIfrRef3 : public CIfrObj, public CIfrOpHeader, public CIfrQuestionHeader { | |
private: | |
EFI_IFR_REF3 *mRef3; | |
public: | |
CIfrRef3 () : CIfrObj (EFI_IFR_REF_OP, (CHAR8 **)NULL, sizeof(EFI_IFR_REF3)), | |
CIfrOpHeader (EFI_IFR_REF_OP, &(GetObjBinAddr<EFI_IFR_REF3>())->Header, sizeof (EFI_IFR_REF3)), | |
CIfrQuestionHeader (&(GetObjBinAddr<EFI_IFR_REF3>())->Question), mRef3(GetObjBinAddr<EFI_IFR_REF3>()) { | |
mRef3->FormId = 0; | |
mRef3->QuestionId = EFI_QUESTION_ID_INVALID; | |
memset (&mRef3->FormSetId, 0, sizeof (EFI_GUID)); | |
} | |
VOID SetFormId (IN EFI_FORM_ID FormId) { | |
mRef3->FormId = FormId; | |
} | |
VOID SetQuestionId (IN EFI_QUESTION_ID QuestionId) { | |
mRef3->QuestionId = QuestionId; | |
} | |
VOID SetFormSetId (IN EFI_GUID FormSetId) { | |
mRef3->FormSetId = FormSetId; | |
} | |
}; | |
class CIfrRef4 : public CIfrObj, public CIfrOpHeader, public CIfrQuestionHeader { | |
private: | |
EFI_IFR_REF4 *mRef4; | |
public: | |
CIfrRef4 () : CIfrObj (EFI_IFR_REF_OP, (CHAR8 **)NULL, sizeof(EFI_IFR_REF4)), | |
CIfrOpHeader (EFI_IFR_REF_OP, &(GetObjBinAddr<EFI_IFR_REF4>())->Header, sizeof(EFI_IFR_REF4)), | |
CIfrQuestionHeader (&(GetObjBinAddr<EFI_IFR_REF4>())->Question), mRef4(GetObjBinAddr<EFI_IFR_REF4>()) { | |
mRef4->FormId = 0; | |
mRef4->QuestionId = EFI_QUESTION_ID_INVALID; | |
memset (&mRef4->FormSetId, 0, sizeof (EFI_GUID)); | |
mRef4->DevicePath = EFI_STRING_ID_INVALID; | |
} | |
VOID SetFormId (IN EFI_FORM_ID FormId) { | |
mRef4->FormId = FormId; | |
} | |
VOID SetQuestionId (IN EFI_QUESTION_ID QuestionId) { | |
mRef4->QuestionId = QuestionId; | |
} | |
VOID SetFormSetId (IN EFI_GUID FormSetId) { | |
mRef4->FormSetId = FormSetId; | |
} | |
VOID SetDevicePath (IN EFI_STRING_ID DevicePath) { | |
mRef4->DevicePath = DevicePath; | |
} | |
}; | |
class CIfrRef5 : public CIfrObj, public CIfrOpHeader, public CIfrQuestionHeader { | |
public: | |
CIfrRef5 () : CIfrObj (EFI_IFR_REF_OP, (CHAR8 **)NULL, sizeof (EFI_IFR_REF5)), | |
CIfrOpHeader (EFI_IFR_REF_OP, &(GetObjBinAddr<EFI_IFR_REF5>())->Header, sizeof (EFI_IFR_REF5)), | |
CIfrQuestionHeader (&(GetObjBinAddr<EFI_IFR_REF5>())->Question) { | |
} | |
}; | |
class CIfrResetButton : public CIfrObj, public CIfrOpHeader, public CIfrStatementHeader { | |
private: | |
EFI_IFR_RESET_BUTTON *mResetButton; | |
public: | |
CIfrResetButton () : CIfrObj (EFI_IFR_RESET_BUTTON_OP), | |
CIfrOpHeader (EFI_IFR_RESET_BUTTON_OP, &(GetObjBinAddr<EFI_IFR_RESET_BUTTON>())->Header), | |
CIfrStatementHeader (&(GetObjBinAddr<EFI_IFR_RESET_BUTTON>())->Statement), mResetButton(GetObjBinAddr<EFI_IFR_RESET_BUTTON>()) { | |
mResetButton->DefaultId = EFI_HII_DEFAULT_CLASS_STANDARD; | |
} | |
VOID SetDefaultId (IN UINT16 DefaultId) { | |
mResetButton->DefaultId = DefaultId; | |
} | |
}; | |
class CIfrCheckBox : public CIfrObj, public CIfrOpHeader, public CIfrQuestionHeader { | |
private: | |
EFI_IFR_CHECKBOX *mCheckBox; | |
public: | |
CIfrCheckBox () : CIfrObj (EFI_IFR_CHECKBOX_OP), | |
CIfrOpHeader (EFI_IFR_CHECKBOX_OP, &(GetObjBinAddr<EFI_IFR_CHECKBOX>())->Header), | |
CIfrQuestionHeader (&(GetObjBinAddr<EFI_IFR_CHECKBOX>())->Question), mCheckBox(GetObjBinAddr<EFI_IFR_CHECKBOX>()) { | |
mCheckBox->Flags = 0; | |
gCurrentQuestion = this; | |
} | |
~CIfrCheckBox () { | |
gCurrentQuestion = NULL; | |
} | |
EFI_VFR_RETURN_CODE SetFlags (IN UINT8 HFlags, UINT8 LFlags) { | |
EFI_VFR_RETURN_CODE Ret; | |
Ret = CIfrQuestionHeader::SetFlags (HFlags); | |
if (Ret != VFR_RETURN_SUCCESS) { | |
return Ret; | |
} | |
if (_FLAG_TEST_AND_CLEAR (LFlags, EFI_IFR_CHECKBOX_DEFAULT)) { | |
mCheckBox->Flags |= EFI_IFR_CHECKBOX_DEFAULT; | |
} | |
if (_FLAG_TEST_AND_CLEAR (LFlags, EFI_IFR_CHECKBOX_DEFAULT_MFG)) { | |
mCheckBox->Flags |= EFI_IFR_CHECKBOX_DEFAULT_MFG; | |
} | |
return _FLAGS_ZERO (LFlags) ? VFR_RETURN_SUCCESS : VFR_RETURN_FLAGS_UNSUPPORTED; | |
} | |
UINT8 GetFlags (VOID) { | |
return mCheckBox->Flags; | |
} | |
}; | |
class CIfrAction : public CIfrObj, public CIfrOpHeader, public CIfrQuestionHeader { | |
private: | |
EFI_IFR_ACTION *mAction; | |
public: | |
CIfrAction () : CIfrObj (EFI_IFR_ACTION_OP), | |
CIfrOpHeader (EFI_IFR_ACTION_OP, &(GetObjBinAddr<EFI_IFR_ACTION>())->Header), | |
CIfrQuestionHeader (&(GetObjBinAddr<EFI_IFR_ACTION>())->Question), mAction(GetObjBinAddr<EFI_IFR_ACTION>()) { | |
mAction->QuestionConfig = EFI_STRING_ID_INVALID; | |
} | |
VOID SetQuestionConfig (IN EFI_STRING_ID QuestionConfig) { | |
mAction->QuestionConfig = QuestionConfig; | |
} | |
}; | |
class CIfrDate : public CIfrObj, public CIfrOpHeader, public CIfrQuestionHeader { | |
private: | |
EFI_IFR_DATE *mDate; | |
public: | |
CIfrDate () : CIfrObj (EFI_IFR_DATE_OP), | |
CIfrOpHeader (EFI_IFR_DATE_OP, &(GetObjBinAddr<EFI_IFR_DATE>())->Header), | |
CIfrQuestionHeader (&(GetObjBinAddr<EFI_IFR_DATE>())->Question), mDate(GetObjBinAddr<EFI_IFR_DATE>()) { | |
mDate->Flags = 0; | |
} | |
EFI_VFR_RETURN_CODE SetFlags (IN UINT8 HFlags, IN UINT8 LFlags) { | |
EFI_VFR_RETURN_CODE Ret; | |
Ret = CIfrQuestionHeader::SetFlags (HFlags); | |
if (Ret != VFR_RETURN_SUCCESS) { | |
return Ret; | |
} | |
if (_FLAG_TEST_AND_CLEAR (LFlags, EFI_QF_DATE_YEAR_SUPPRESS)) { | |
mDate->Flags |= EFI_QF_DATE_YEAR_SUPPRESS; | |
} | |
if (_FLAG_TEST_AND_CLEAR (LFlags, EFI_QF_DATE_MONTH_SUPPRESS)) { | |
mDate->Flags |= EFI_QF_DATE_MONTH_SUPPRESS; | |
} | |
if (_FLAG_TEST_AND_CLEAR (LFlags, EFI_QF_DATE_DAY_SUPPRESS)) { | |
mDate->Flags |= EFI_QF_DATE_DAY_SUPPRESS; | |
} | |
if (_FLAG_TEST_AND_CLEAR (LFlags, QF_DATE_STORAGE_NORMAL)) { | |
mDate->Flags |= QF_DATE_STORAGE_NORMAL; | |
} else if (_FLAG_TEST_AND_CLEAR (LFlags, QF_DATE_STORAGE_TIME)) { | |
mDate->Flags |= QF_DATE_STORAGE_TIME; | |
} else if (_FLAG_TEST_AND_CLEAR (LFlags, QF_DATE_STORAGE_WAKEUP)) { | |
mDate->Flags |= QF_DATE_STORAGE_WAKEUP; | |
} | |
return _FLAGS_ZERO (LFlags) ? VFR_RETURN_SUCCESS : VFR_RETURN_FLAGS_UNSUPPORTED; | |
} | |
}; | |
class CIfrNumeric : public CIfrObj, public CIfrOpHeader, public CIfrQuestionHeader, public CIfrMinMaxStepData { | |
private: | |
EFI_IFR_NUMERIC *mNumeric; | |
public: | |
CIfrNumeric () : CIfrObj (EFI_IFR_NUMERIC_OP, (CHAR8 **)NULL, sizeof (EFI_IFR_NUMERIC), TRUE), | |
CIfrOpHeader (EFI_IFR_NUMERIC_OP, &(GetObjBinAddr<EFI_IFR_NUMERIC>())->Header), | |
CIfrQuestionHeader (&(GetObjBinAddr<EFI_IFR_NUMERIC>())->Question), | |
CIfrMinMaxStepData (&(GetObjBinAddr<EFI_IFR_NUMERIC>())->data, TRUE), mNumeric(GetObjBinAddr<EFI_IFR_NUMERIC>()) { | |
mNumeric->Flags = EFI_IFR_NUMERIC_SIZE_1 | EFI_IFR_DISPLAY_UINT_DEC; | |
gCurrentQuestion = this; | |
gCurrentMinMaxData = this; | |
} | |
~CIfrNumeric () { | |
gCurrentQuestion = NULL; | |
gCurrentMinMaxData = NULL; | |
} | |
VOID ShrinkBinSize (IN UINT16 Size) { | |
// | |
// Update the buffer size which is truly be used later. | |
// | |
ShrinkObjBin(Size); | |
DecLength(Size); | |
// | |
// Allocate buffer in gCFormPkg. | |
// | |
_EMIT_PENDING_OBJ(); | |
// | |
// Update the buffer pointer used by other class. | |
// | |
mNumeric = GetObjBinAddr<EFI_IFR_NUMERIC>(); | |
UpdateHeader (&mNumeric->Header); | |
UpdateCIfrQuestionHeader(&mNumeric->Question); | |
UpdateCIfrMinMaxStepData(&mNumeric->data); | |
} | |
EFI_VFR_RETURN_CODE SetFlags (IN UINT8 HFlags, IN UINT8 LFlags, BOOLEAN DisplaySettingsSpecified = FALSE) { | |
EFI_VFR_RETURN_CODE Ret; | |
Ret = CIfrQuestionHeader::SetFlags (HFlags); | |
if (Ret != VFR_RETURN_SUCCESS) { | |
return Ret; | |
} | |
if (DisplaySettingsSpecified == FALSE) { | |
mNumeric->Flags = LFlags | EFI_IFR_DISPLAY_UINT_DEC; | |
} else { | |
mNumeric->Flags = LFlags; | |
} | |
return VFR_RETURN_SUCCESS; | |
} | |
EFI_VFR_RETURN_CODE SetFlagsForBitField (IN UINT8 HFlags, IN UINT8 LFlags, BOOLEAN DisplaySettingsSpecified = FALSE) { | |
EFI_VFR_RETURN_CODE Ret; | |
Ret = CIfrQuestionHeader::SetFlags (HFlags); | |
if (Ret != VFR_RETURN_SUCCESS) { | |
return Ret; | |
} | |
if (DisplaySettingsSpecified == FALSE) { | |
mNumeric->Flags = LFlags | EDKII_IFR_DISPLAY_UINT_DEC_BIT; | |
} else { | |
mNumeric->Flags = LFlags; | |
} | |
return VFR_RETURN_SUCCESS; | |
} | |
UINT8 GetNumericFlags () { | |
return mNumeric->Flags; | |
} | |
}; | |
class CIfrOneOf : public CIfrObj, public CIfrOpHeader, public CIfrQuestionHeader, public CIfrMinMaxStepData { | |
private: | |
EFI_IFR_ONE_OF *mOneOf; | |
public: | |
CIfrOneOf () : CIfrObj (EFI_IFR_ONE_OF_OP, (CHAR8 **)NULL, sizeof (EFI_IFR_ONE_OF), TRUE), | |
CIfrOpHeader (EFI_IFR_ONE_OF_OP, &(GetObjBinAddr<EFI_IFR_ONE_OF>())->Header), | |
CIfrQuestionHeader (&(GetObjBinAddr<EFI_IFR_ONE_OF>())->Question), | |
CIfrMinMaxStepData (&(GetObjBinAddr<EFI_IFR_ONE_OF>())->data), mOneOf(GetObjBinAddr<EFI_IFR_ONE_OF>()) { | |
mOneOf->Flags = 0; | |
gCurrentQuestion = this; | |
gCurrentMinMaxData = this; | |
} | |
~CIfrOneOf () { | |
gCurrentQuestion = NULL; | |
gCurrentMinMaxData = NULL; | |
} | |
EFI_VFR_RETURN_CODE SetFlags (IN UINT8 HFlags, IN UINT8 LFlags) { | |
EFI_VFR_RETURN_CODE Ret; | |
Ret = CIfrQuestionHeader::SetFlags (HFlags); | |
if (Ret != VFR_RETURN_SUCCESS) { | |
return Ret; | |
} | |
if (LFlags & EFI_IFR_DISPLAY) { | |
mOneOf->Flags = LFlags; | |
} else { | |
mOneOf->Flags = LFlags | EFI_IFR_DISPLAY_UINT_DEC; | |
} | |
return VFR_RETURN_SUCCESS; | |
} | |
EFI_VFR_RETURN_CODE SetFlagsForBitField (IN UINT8 HFlags, IN UINT8 LFlags) { | |
EFI_VFR_RETURN_CODE Ret; | |
Ret = CIfrQuestionHeader::SetFlags (HFlags); | |
if (Ret != VFR_RETURN_SUCCESS) { | |
return Ret; | |
} | |
if (LFlags & EDKII_IFR_DISPLAY_BIT) { | |
mOneOf->Flags = LFlags; | |
} else { | |
mOneOf->Flags = LFlags | EDKII_IFR_DISPLAY_UINT_DEC_BIT; | |
} | |
return VFR_RETURN_SUCCESS; | |
} | |
VOID ShrinkBinSize (IN UINT16 Size) { | |
// | |
// Update the buffer size which is truly be used later. | |
// | |
ShrinkObjBin(Size); | |
DecLength(Size); | |
// | |
// Allocate buffer in gCFormPkg. | |
// | |
_EMIT_PENDING_OBJ(); | |
// | |
// Update the buffer pointer used by other class. | |
// | |
mOneOf = GetObjBinAddr<EFI_IFR_ONE_OF>(); | |
UpdateHeader (&mOneOf->Header); | |
UpdateCIfrQuestionHeader(&mOneOf->Question); | |
UpdateCIfrMinMaxStepData(&mOneOf->data); | |
} | |
}; | |
class CIfrString : public CIfrObj, public CIfrOpHeader, public CIfrQuestionHeader { | |
private: | |
EFI_IFR_STRING *mString; | |
public: | |
CIfrString () : CIfrObj (EFI_IFR_STRING_OP), | |
CIfrOpHeader (EFI_IFR_STRING_OP, &(GetObjBinAddr<EFI_IFR_STRING>())->Header), | |
CIfrQuestionHeader (&(GetObjBinAddr<EFI_IFR_STRING>())->Question), mString(GetObjBinAddr<EFI_IFR_STRING>()) { | |
mString->Flags = 0; | |
mString->MinSize = 0; | |
mString->MaxSize = 0; | |
gCurrentQuestion = this; | |
} | |
~CIfrString () { | |
gCurrentQuestion = NULL; | |
} | |
EFI_VFR_RETURN_CODE SetFlags (IN UINT8 HFlags, IN UINT8 LFlags) { | |
EFI_VFR_RETURN_CODE Ret; | |
Ret = CIfrQuestionHeader::SetFlags (HFlags); | |
if (Ret != VFR_RETURN_SUCCESS) { | |
return Ret; | |
} | |
if (_FLAG_TEST_AND_CLEAR (LFlags, EFI_IFR_STRING_MULTI_LINE)) { | |
mString->Flags |= EFI_IFR_STRING_MULTI_LINE; | |
} | |
return _FLAGS_ZERO (LFlags) ? VFR_RETURN_SUCCESS : VFR_RETURN_FLAGS_UNSUPPORTED; | |
} | |
VOID SetMinSize (IN UINT8 Flags) { | |
mString->MinSize = Flags; | |
} | |
VOID SetMaxSize (IN UINT8 MaxSize) { | |
mString->MaxSize = MaxSize; | |
} | |
}; | |
class CIfrPassword : public CIfrObj, public CIfrOpHeader, public CIfrQuestionHeader { | |
private: | |
EFI_IFR_PASSWORD *mPassword; | |
public: | |
CIfrPassword () : CIfrObj (EFI_IFR_PASSWORD_OP), | |
CIfrOpHeader (EFI_IFR_PASSWORD_OP, &(GetObjBinAddr<EFI_IFR_PASSWORD>())->Header), | |
CIfrQuestionHeader (&(GetObjBinAddr<EFI_IFR_PASSWORD>())->Question), mPassword(GetObjBinAddr<EFI_IFR_PASSWORD>()) { | |
mPassword->MinSize = 0; | |
mPassword->MaxSize = 0; | |
gCurrentQuestion = this; | |
} | |
~CIfrPassword () { | |
gCurrentQuestion = NULL; | |
} | |
VOID SetMinSize (IN UINT16 MinSize) { | |
mPassword->MinSize = MinSize; | |
} | |
VOID SetMaxSize (IN UINT16 MaxSize) { | |
mPassword->MaxSize = MaxSize; | |
} | |
}; | |
class CIfrOrderedList : public CIfrObj, public CIfrOpHeader, public CIfrQuestionHeader { | |
private: | |
EFI_IFR_ORDERED_LIST *mOrderedList; | |
public: | |
CIfrOrderedList () : CIfrObj (EFI_IFR_ORDERED_LIST_OP), | |
CIfrOpHeader (EFI_IFR_ORDERED_LIST_OP, &(GetObjBinAddr<EFI_IFR_ORDERED_LIST>())->Header), | |
CIfrQuestionHeader (&(GetObjBinAddr<EFI_IFR_ORDERED_LIST>())->Question), mOrderedList(GetObjBinAddr<EFI_IFR_ORDERED_LIST>()) { | |
mOrderedList->MaxContainers = 0; | |
mOrderedList->Flags = 0; | |
gCurrentQuestion = this; | |
} | |
~CIfrOrderedList () { | |
gCurrentQuestion = NULL; | |
} | |
VOID SetMaxContainers (IN UINT8 MaxContainers) { | |
mOrderedList->MaxContainers = MaxContainers; | |
} | |
EFI_VFR_RETURN_CODE SetFlags (IN UINT8 HFlags, IN UINT8 LFlags) { | |
EFI_VFR_RETURN_CODE Ret; | |
Ret = CIfrQuestionHeader::SetFlags (HFlags); | |
if (Ret != VFR_RETURN_SUCCESS) { | |
return Ret; | |
} | |
if (_FLAG_TEST_AND_CLEAR (LFlags, EFI_IFR_UNIQUE_SET)) { | |
mOrderedList->Flags |= EFI_IFR_UNIQUE_SET; | |
} | |
if (_FLAG_TEST_AND_CLEAR (LFlags, EFI_IFR_NO_EMPTY_SET)) { | |
mOrderedList->Flags |= EFI_IFR_NO_EMPTY_SET; | |
} | |
return _FLAGS_ZERO (LFlags) ? VFR_RETURN_SUCCESS : VFR_RETURN_FLAGS_UNSUPPORTED; | |
} | |
}; | |
class CIfrTime : public CIfrObj, public CIfrOpHeader, public CIfrQuestionHeader { | |
private: | |
EFI_IFR_TIME *mTime; | |
public: | |
CIfrTime () : CIfrObj (EFI_IFR_TIME_OP), | |
CIfrOpHeader (EFI_IFR_TIME_OP, &(GetObjBinAddr<EFI_IFR_TIME>())->Header), | |
CIfrQuestionHeader (&(GetObjBinAddr<EFI_IFR_TIME>())->Question), mTime(GetObjBinAddr<EFI_IFR_TIME>()) { | |
mTime->Flags = 0; | |
} | |
EFI_VFR_RETURN_CODE SetFlags (IN UINT8 HFlags, IN UINT8 LFlags) { | |
EFI_VFR_RETURN_CODE Ret; | |
Ret = CIfrQuestionHeader::SetFlags (HFlags); | |
if (Ret != VFR_RETURN_SUCCESS) { | |
return Ret; | |
} | |
if (_FLAG_TEST_AND_CLEAR (LFlags, QF_TIME_HOUR_SUPPRESS)) { | |
mTime->Flags |= QF_TIME_HOUR_SUPPRESS; | |
} | |
if (_FLAG_TEST_AND_CLEAR (LFlags, QF_TIME_MINUTE_SUPPRESS)) { | |
mTime->Flags |= QF_TIME_MINUTE_SUPPRESS; | |
} | |
if (_FLAG_TEST_AND_CLEAR (LFlags, QF_TIME_SECOND_SUPPRESS)) { | |
mTime->Flags |= QF_TIME_SECOND_SUPPRESS; | |
} | |
if (_FLAG_TEST_AND_CLEAR (LFlags, QF_TIME_STORAGE_NORMAL)) { | |
mTime->Flags |= QF_TIME_STORAGE_NORMAL; | |
} else if (_FLAG_TEST_AND_CLEAR (LFlags, QF_TIME_STORAGE_TIME)) { | |
mTime->Flags |= QF_TIME_STORAGE_TIME; | |
} else if (_FLAG_TEST_AND_CLEAR (LFlags, QF_TIME_STORAGE_WAKEUP)) { | |
mTime->Flags |= QF_TIME_STORAGE_WAKEUP; | |
} | |
return _FLAGS_ZERO (LFlags) ? VFR_RETURN_SUCCESS : VFR_RETURN_FLAGS_UNSUPPORTED; | |
} | |
}; | |
class CIfrDisableIf : public CIfrObj, public CIfrOpHeader { | |
public: | |
CIfrDisableIf () : CIfrObj (EFI_IFR_DISABLE_IF_OP), | |
CIfrOpHeader (EFI_IFR_DISABLE_IF_OP, &(GetObjBinAddr<EFI_IFR_DISABLE_IF>())->Header) {} | |
}; | |
class CIfrSuppressIf : public CIfrObj, public CIfrOpHeader { | |
public: | |
CIfrSuppressIf () : CIfrObj (EFI_IFR_SUPPRESS_IF_OP), | |
CIfrOpHeader (EFI_IFR_SUPPRESS_IF_OP, &(GetObjBinAddr<EFI_IFR_SUPPRESS_IF>())->Header) {} | |
}; | |
class CIfrGrayOutIf : public CIfrObj, public CIfrOpHeader { | |
public: | |
CIfrGrayOutIf () : CIfrObj (EFI_IFR_GRAY_OUT_IF_OP), | |
CIfrOpHeader (EFI_IFR_GRAY_OUT_IF_OP, &(GetObjBinAddr<EFI_IFR_GRAY_OUT_IF>())->Header) {} | |
}; | |
class CIfrInconsistentIf : public CIfrObj, public CIfrOpHeader { | |
private: | |
EFI_IFR_INCONSISTENT_IF *mInconsistentIf; | |
public: | |
CIfrInconsistentIf () : CIfrObj (EFI_IFR_INCONSISTENT_IF_OP), | |
CIfrOpHeader (EFI_IFR_INCONSISTENT_IF_OP, &(GetObjBinAddr<EFI_IFR_INCONSISTENT_IF>())->Header), mInconsistentIf(GetObjBinAddr<EFI_IFR_INCONSISTENT_IF>()) { | |
mInconsistentIf->Error = EFI_STRING_ID_INVALID; | |
} | |
VOID SetError (IN EFI_STRING_ID Error) { | |
mInconsistentIf->Error = Error; | |
} | |
}; | |
class CIfrWarningIf : public CIfrObj, public CIfrOpHeader { | |
private: | |
EFI_IFR_WARNING_IF *mWarningIf; | |
public: | |
CIfrWarningIf () : CIfrObj (EFI_IFR_WARNING_IF_OP), | |
CIfrOpHeader (EFI_IFR_WARNING_IF_OP, &(GetObjBinAddr<EFI_IFR_WARNING_IF>())->Header), mWarningIf(GetObjBinAddr<EFI_IFR_WARNING_IF>()) { | |
mWarningIf->Warning = EFI_STRING_ID_INVALID; | |
mWarningIf->TimeOut = 0; | |
} | |
VOID SetWarning (IN EFI_STRING_ID Warning) { | |
mWarningIf->Warning = Warning; | |
} | |
VOID SetTimeOut (IN UINT8 TimeOut) { | |
mWarningIf->TimeOut = TimeOut; | |
} | |
}; | |
class CIfrNoSubmitIf : public CIfrObj, public CIfrOpHeader { | |
private: | |
EFI_IFR_NO_SUBMIT_IF *mNoSubmitIf; | |
public: | |
CIfrNoSubmitIf () : CIfrObj (EFI_IFR_NO_SUBMIT_IF_OP), | |
CIfrOpHeader (EFI_IFR_NO_SUBMIT_IF_OP, &(GetObjBinAddr<EFI_IFR_NO_SUBMIT_IF>())->Header), mNoSubmitIf(GetObjBinAddr<EFI_IFR_NO_SUBMIT_IF>()) { | |
mNoSubmitIf->Error = EFI_STRING_ID_INVALID; | |
} | |
VOID SetError (IN EFI_STRING_ID Error) { | |
mNoSubmitIf->Error = Error; | |
} | |
}; | |
class CIfrRefresh : public CIfrObj, public CIfrOpHeader { | |
private: | |
EFI_IFR_REFRESH *mRefresh; | |
public: | |
CIfrRefresh () : CIfrObj (EFI_IFR_REFRESH_OP), | |
CIfrOpHeader (EFI_IFR_REFRESH_OP, &(GetObjBinAddr<EFI_IFR_REFRESH>())->Header), mRefresh(GetObjBinAddr<EFI_IFR_REFRESH>()) { | |
mRefresh->RefreshInterval = 0; | |
} | |
VOID SetRefreshInterval (IN UINT8 RefreshInterval) { | |
mRefresh->RefreshInterval = RefreshInterval; | |
} | |
}; | |
class CIfrRefreshId : public CIfrObj, public CIfrOpHeader { | |
private: | |
EFI_IFR_REFRESH_ID *mRefreshId; | |
public: | |
CIfrRefreshId () : CIfrObj (EFI_IFR_REFRESH_ID_OP), | |
CIfrOpHeader (EFI_IFR_REFRESH_ID_OP, &(GetObjBinAddr<EFI_IFR_REFRESH_ID>())->Header), mRefreshId(GetObjBinAddr<EFI_IFR_REFRESH_ID>()) { | |
memset (&mRefreshId->RefreshEventGroupId, 0, sizeof (EFI_GUID)); | |
} | |
VOID SetRefreshEventGroutId (IN EFI_GUID *RefreshEventGroupId) { | |
memmove (&mRefreshId->RefreshEventGroupId, RefreshEventGroupId, sizeof (EFI_GUID)); | |
} | |
}; | |
class CIfrVarStoreDevice : public CIfrObj, public CIfrOpHeader { | |
private: | |
EFI_IFR_VARSTORE_DEVICE *mVarStoreDevice; | |
public: | |
CIfrVarStoreDevice () : CIfrObj (EFI_IFR_VARSTORE_DEVICE_OP), | |
CIfrOpHeader (EFI_IFR_VARSTORE_DEVICE_OP, &(GetObjBinAddr<EFI_IFR_VARSTORE_DEVICE>())->Header), mVarStoreDevice(GetObjBinAddr<EFI_IFR_VARSTORE_DEVICE>()) { | |
mVarStoreDevice->DevicePath = EFI_STRING_ID_INVALID; | |
} | |
VOID SetDevicePath (IN EFI_STRING_ID DevicePath) { | |
mVarStoreDevice->DevicePath = DevicePath; | |
} | |
}; | |
class CIfrOneOfOption : public CIfrObj, public CIfrOpHeader { | |
private: | |
EFI_IFR_ONE_OF_OPTION *mOneOfOption; | |
public: | |
CIfrOneOfOption (UINT8 Size) : CIfrObj (EFI_IFR_ONE_OF_OPTION_OP, (CHAR8 **)NULL, Size), | |
CIfrOpHeader (EFI_IFR_ONE_OF_OPTION_OP, &(GetObjBinAddr<EFI_IFR_ONE_OF_OPTION>())->Header, Size), mOneOfOption(GetObjBinAddr<EFI_IFR_ONE_OF_OPTION>()) { | |
mOneOfOption->Flags = 0; | |
mOneOfOption->Option = EFI_STRING_ID_INVALID; | |
mOneOfOption->Type = EFI_IFR_TYPE_OTHER; | |
memset (&mOneOfOption->Value, 0, Size - OFFSET_OF (EFI_IFR_ONE_OF_OPTION, Value)); | |
} | |
VOID SetOption (IN EFI_STRING_ID Option) { | |
mOneOfOption->Option = Option; | |
} | |
EFI_VFR_RETURN_CODE SetFlags (IN UINT8 LFlags) { | |
mOneOfOption->Flags = 0; | |
if (_FLAG_TEST_AND_CLEAR (LFlags, EFI_IFR_OPTION_DEFAULT)) { | |
mOneOfOption->Flags |= EFI_IFR_OPTION_DEFAULT; | |
} | |
if (_FLAG_TEST_AND_CLEAR (LFlags, EFI_IFR_OPTION_DEFAULT_MFG)) { | |
mOneOfOption->Flags |= EFI_IFR_OPTION_DEFAULT_MFG; | |
} | |
if (_IS_EQUAL (LFlags, EFI_IFR_TYPE_NUM_SIZE_8)) { | |
_FLAG_CLEAR (LFlags, EFI_IFR_TYPE_NUM_SIZE_8); | |
mOneOfOption->Flags |= EFI_IFR_TYPE_NUM_SIZE_8; | |
} else if (_IS_EQUAL (LFlags, EFI_IFR_TYPE_NUM_SIZE_16)) { | |
_FLAG_CLEAR (LFlags, EFI_IFR_TYPE_NUM_SIZE_16); | |
mOneOfOption->Flags |= EFI_IFR_TYPE_NUM_SIZE_16; | |
} else if (_IS_EQUAL (LFlags, EFI_IFR_TYPE_NUM_SIZE_32)) { | |
_FLAG_CLEAR (LFlags, EFI_IFR_TYPE_NUM_SIZE_32); | |
mOneOfOption->Flags |= EFI_IFR_TYPE_NUM_SIZE_32; | |
} else if (_IS_EQUAL (LFlags, EFI_IFR_TYPE_NUM_SIZE_64)) { | |
_FLAG_CLEAR (LFlags, EFI_IFR_TYPE_NUM_SIZE_64); | |
mOneOfOption->Flags |= EFI_IFR_TYPE_NUM_SIZE_64; | |
} else if (_IS_EQUAL (LFlags, EFI_IFR_TYPE_BOOLEAN)) { | |
_FLAG_CLEAR (LFlags, EFI_IFR_TYPE_BOOLEAN); | |
mOneOfOption->Flags |= EFI_IFR_TYPE_BOOLEAN; | |
} else if (_IS_EQUAL (LFlags, EFI_IFR_TYPE_TIME)) { | |
_FLAG_CLEAR (LFlags, EFI_IFR_TYPE_TIME); | |
mOneOfOption->Flags |= EFI_IFR_TYPE_TIME; | |
} else if (_IS_EQUAL (LFlags, EFI_IFR_TYPE_DATE)) { | |
_FLAG_CLEAR (LFlags, EFI_IFR_TYPE_DATE); | |
mOneOfOption->Flags |= EFI_IFR_TYPE_DATE; | |
} else if (_IS_EQUAL (LFlags, EFI_IFR_TYPE_STRING)) { | |
_FLAG_CLEAR (LFlags, EFI_IFR_TYPE_STRING); | |
mOneOfOption->Flags |= EFI_IFR_TYPE_STRING; | |
} else if (_IS_EQUAL (LFlags, EFI_IFR_TYPE_OTHER)) { | |
_FLAG_CLEAR (LFlags, EFI_IFR_TYPE_OTHER); | |
mOneOfOption->Flags |= EFI_IFR_TYPE_OTHER; | |
} | |
return _FLAGS_ZERO (LFlags) ? VFR_RETURN_SUCCESS : VFR_RETURN_FLAGS_UNSUPPORTED; | |
} | |
VOID SetType (IN UINT8 Type) { | |
mOneOfOption->Type = Type; | |
} | |
VOID SetValue (IN EFI_IFR_TYPE_VALUE Value) { | |
memmove (&mOneOfOption->Value, &Value, mOneOfOption->Header.Length - OFFSET_OF (EFI_IFR_ONE_OF_OPTION, Value)); | |
} | |
UINT8 GetFlags (VOID) { | |
return mOneOfOption->Flags; | |
} | |
}; | |
static EFI_GUID IfrTianoGuid = EFI_IFR_TIANO_GUID; | |
static EFI_GUID IfrFrameworkGuid = EFI_IFR_FRAMEWORK_GUID; | |
class CIfrClass : public CIfrObj, public CIfrOpHeader { | |
private: | |
EFI_IFR_GUID_CLASS *mClass; | |
public: | |
CIfrClass () : CIfrObj (EFI_IFR_GUID_OP, (CHAR8 **)NULL, sizeof (EFI_IFR_GUID_CLASS)), | |
CIfrOpHeader (EFI_IFR_GUID_OP, &(GetObjBinAddr<EFI_IFR_GUID_CLASS>())->Header, sizeof (EFI_IFR_GUID_CLASS)), mClass(GetObjBinAddr<EFI_IFR_GUID_CLASS>()) { | |
mClass->ExtendOpCode = EFI_IFR_EXTEND_OP_CLASS; | |
mClass->Guid = IfrTianoGuid; | |
mClass->Class = EFI_NON_DEVICE_CLASS; | |
} | |
VOID SetClass (IN UINT16 Class) { | |
mClass->Class = Class; | |
} | |
}; | |
class CIfrSubClass : public CIfrObj, public CIfrOpHeader { | |
private: | |
EFI_IFR_GUID_SUBCLASS *mSubClass; | |
public: | |
CIfrSubClass () : CIfrObj (EFI_IFR_GUID_OP, (CHAR8 **)NULL, sizeof (EFI_IFR_GUID_SUBCLASS)), | |
CIfrOpHeader (EFI_IFR_GUID_OP, &(GetObjBinAddr<EFI_IFR_GUID_SUBCLASS>())->Header, sizeof (EFI_IFR_GUID_SUBCLASS)), mSubClass(GetObjBinAddr<EFI_IFR_GUID_SUBCLASS>()) { | |
mSubClass->ExtendOpCode = EFI_IFR_EXTEND_OP_SUBCLASS; | |
mSubClass->Guid = IfrTianoGuid; | |
mSubClass->SubClass = EFI_SETUP_APPLICATION_SUBCLASS; | |
} | |
VOID SetSubClass (IN UINT16 SubClass) { | |
mSubClass->SubClass = SubClass; | |
} | |
}; | |
class CIfrLabel : public CIfrObj, public CIfrOpHeader { | |
private: | |
EFI_IFR_GUID_LABEL *mLabel; | |
public: | |
CIfrLabel () : CIfrObj (EFI_IFR_GUID_OP, (CHAR8 **)NULL, sizeof (EFI_IFR_GUID_LABEL)), | |
CIfrOpHeader (EFI_IFR_GUID_OP, &(GetObjBinAddr<EFI_IFR_GUID_LABEL>())->Header, sizeof (EFI_IFR_GUID_LABEL)), mLabel(GetObjBinAddr<EFI_IFR_GUID_LABEL>()) { | |
mLabel->ExtendOpCode = EFI_IFR_EXTEND_OP_LABEL; | |
mLabel->Guid = IfrTianoGuid; | |
} | |
VOID SetNumber (IN UINT16 Number) { | |
mLabel->Number = Number; | |
} | |
}; | |
class CIfrBanner : public CIfrObj, public CIfrOpHeader { | |
private: | |
EFI_IFR_GUID_BANNER *mBanner; | |
public: | |
CIfrBanner () : CIfrObj (EFI_IFR_GUID_OP, (CHAR8 **)NULL, sizeof (EFI_IFR_GUID_BANNER)), | |
CIfrOpHeader (EFI_IFR_GUID_OP, &(GetObjBinAddr<EFI_IFR_GUID_BANNER>())->Header, sizeof (EFI_IFR_GUID_BANNER)), mBanner(GetObjBinAddr<EFI_IFR_GUID_BANNER>()) { | |
mBanner->ExtendOpCode = EFI_IFR_EXTEND_OP_BANNER; | |
mBanner->Guid = IfrTianoGuid; | |
} | |
VOID SetTitle (IN EFI_STRING_ID StringId) { | |
mBanner->Title = StringId; | |
} | |
VOID SetLine (IN UINT16 Line) { | |
mBanner->LineNumber = Line; | |
} | |
VOID SetAlign (IN UINT8 Align) { | |
mBanner->Alignment = Align; | |
} | |
}; | |
class CIfrOptionKey : public CIfrObj, public CIfrOpHeader { | |
private: | |
EFI_IFR_GUID_OPTIONKEY *mOptionKey; | |
public: | |
CIfrOptionKey ( | |
IN EFI_QUESTION_ID QuestionId, | |
IN EFI_IFR_TYPE_VALUE &OptionValue, | |
IN EFI_QUESTION_ID KeyValue | |
) : CIfrObj (EFI_IFR_GUID_OP, (CHAR8 **)NULL, sizeof (EFI_IFR_GUID_OPTIONKEY)), | |
CIfrOpHeader (EFI_IFR_GUID_OP, &(GetObjBinAddr<EFI_IFR_GUID_OPTIONKEY>())->Header, sizeof (EFI_IFR_GUID_OPTIONKEY)), mOptionKey(GetObjBinAddr<EFI_IFR_GUID_OPTIONKEY>()) { | |
mOptionKey->ExtendOpCode = EFI_IFR_EXTEND_OP_OPTIONKEY; | |
mOptionKey->Guid = IfrFrameworkGuid; | |
mOptionKey->QuestionId = QuestionId; | |
mOptionKey->OptionValue = OptionValue; | |
mOptionKey->KeyValue = KeyValue; | |
} | |
}; | |
class CIfrVarEqName : public CIfrObj, public CIfrOpHeader { | |
private: | |
EFI_IFR_GUID_VAREQNAME *mVarEqName; | |
public: | |
CIfrVarEqName ( | |
IN EFI_QUESTION_ID QuestionId, | |
IN EFI_STRING_ID NameId | |
) : CIfrObj (EFI_IFR_GUID_OP, (CHAR8 **)NULL, sizeof (EFI_IFR_GUID_VAREQNAME)), | |
CIfrOpHeader (EFI_IFR_GUID_OP, &(GetObjBinAddr<EFI_IFR_GUID_VAREQNAME>())->Header, sizeof (EFI_IFR_GUID_VAREQNAME)), mVarEqName(GetObjBinAddr<EFI_IFR_GUID_VAREQNAME>()) { | |
mVarEqName->ExtendOpCode = EFI_IFR_EXTEND_OP_VAREQNAME; | |
mVarEqName->Guid = IfrFrameworkGuid; | |
mVarEqName->QuestionId = QuestionId; | |
mVarEqName->NameId = NameId; | |
} | |
}; | |
class CIfrTimeout : public CIfrObj, public CIfrOpHeader { | |
private: | |
EFI_IFR_GUID_TIMEOUT *mTimeout; | |
public: | |
CIfrTimeout (IN UINT16 Timeout = 0) : CIfrObj (EFI_IFR_GUID_OP, (CHAR8 **)NULL, sizeof (EFI_IFR_GUID_TIMEOUT)), | |
CIfrOpHeader (EFI_IFR_GUID_OP, &(GetObjBinAddr<EFI_IFR_GUID_TIMEOUT>())->Header, sizeof (EFI_IFR_GUID_TIMEOUT)), mTimeout(GetObjBinAddr<EFI_IFR_GUID_TIMEOUT>()) { | |
mTimeout->ExtendOpCode = EFI_IFR_EXTEND_OP_TIMEOUT; | |
mTimeout->Guid = IfrTianoGuid; | |
mTimeout->TimeOut = Timeout; | |
} | |
VOID SetTimeout (IN UINT16 Timeout) { | |
mTimeout->TimeOut = Timeout; | |
} | |
}; | |
class CIfrGuid : public CIfrObj, public CIfrOpHeader { | |
private: | |
EFI_IFR_GUID *mGuid; | |
public: | |
CIfrGuid (UINT8 Size) : CIfrObj (EFI_IFR_GUID_OP, (CHAR8 **)NULL, sizeof (EFI_IFR_GUID)+Size), | |
CIfrOpHeader (EFI_IFR_GUID_OP, &(GetObjBinAddr<EFI_IFR_GUID>())->Header, sizeof (EFI_IFR_GUID)+Size), mGuid(GetObjBinAddr<EFI_IFR_GUID>()) { | |
memset (&mGuid->Guid, 0, sizeof (EFI_GUID)); | |
} | |
VOID SetGuid (IN EFI_GUID *Guid) { | |
memmove (&mGuid->Guid, Guid, sizeof (EFI_GUID)); | |
} | |
VOID SetData (IN UINT8* DataBuff, IN UINT8 Size) { | |
memmove ((UINT8 *)mGuid + sizeof (EFI_IFR_GUID), DataBuff, Size); | |
} | |
}; | |
class CIfrDup : public CIfrObj, public CIfrOpHeader { | |
public: | |
CIfrDup ( | |
IN UINT32 LineNo | |
) : CIfrObj (EFI_IFR_DUP_OP), | |
CIfrOpHeader (EFI_IFR_DUP_OP, &(GetObjBinAddr<EFI_IFR_DUP>())->Header) { | |
SetLineNo (LineNo); | |
} | |
}; | |
class CIfrEqIdId : public CIfrObj, public CIfrOpHeader { | |
private: | |
EFI_IFR_EQ_ID_ID *mEqIdId; | |
public: | |
CIfrEqIdId ( | |
IN UINT32 LineNo | |
) : CIfrObj (EFI_IFR_EQ_ID_ID_OP), | |
CIfrOpHeader (EFI_IFR_EQ_ID_ID_OP, &(GetObjBinAddr<EFI_IFR_EQ_ID_ID>())->Header), mEqIdId(GetObjBinAddr<EFI_IFR_EQ_ID_ID>()) { | |
SetLineNo (LineNo); | |
mEqIdId->QuestionId1 = EFI_QUESTION_ID_INVALID; | |
mEqIdId->QuestionId2 = EFI_QUESTION_ID_INVALID; | |
} | |
VOID SetQuestionId1 ( | |
IN EFI_QUESTION_ID QuestionId, | |
IN CHAR8 *VarIdStr, | |
IN UINT32 LineNo | |
) { | |
if (QuestionId != EFI_QUESTION_ID_INVALID) { | |
mEqIdId->QuestionId1 = QuestionId; | |
} else { | |
gCFormPkg.AssignPending (VarIdStr, (VOID *)(&mEqIdId->QuestionId1), sizeof (EFI_QUESTION_ID), LineNo, NO_QST_REFED); | |
} | |
} | |
VOID SetQuestionId2 ( | |
IN EFI_QUESTION_ID QuestionId, | |
IN CHAR8 *VarIdStr, | |
IN UINT32 LineNo | |
) { | |
if (QuestionId != EFI_QUESTION_ID_INVALID) { | |
mEqIdId->QuestionId2 = QuestionId; | |
} else { | |
gCFormPkg.AssignPending (VarIdStr, (VOID *)(&mEqIdId->QuestionId2), sizeof (EFI_QUESTION_ID), LineNo, NO_QST_REFED); | |
} | |
} | |
}; | |
class CIfrEqIdVal : public CIfrObj, public CIfrOpHeader { | |
private: | |
EFI_IFR_EQ_ID_VAL *mEqIdVal; | |
public: | |
CIfrEqIdVal ( | |
IN UINT32 LineNo | |
) : CIfrObj (EFI_IFR_EQ_ID_VAL_OP), | |
CIfrOpHeader (EFI_IFR_EQ_ID_VAL_OP, &(GetObjBinAddr<EFI_IFR_EQ_ID_VAL>())->Header), mEqIdVal(GetObjBinAddr<EFI_IFR_EQ_ID_VAL>()) { | |
SetLineNo (LineNo); | |
mEqIdVal->QuestionId = EFI_QUESTION_ID_INVALID; | |
} | |
VOID SetQuestionId ( | |
IN EFI_QUESTION_ID QuestionId, | |
IN CHAR8 *VarIdStr, | |
IN UINT32 LineNo | |
) { | |
if (QuestionId != EFI_QUESTION_ID_INVALID) { | |
mEqIdVal->QuestionId = QuestionId; | |
} else { | |
gCFormPkg.AssignPending (VarIdStr, (VOID *)(&mEqIdVal->QuestionId), sizeof (EFI_QUESTION_ID), LineNo, NO_QST_REFED); | |
} | |
} | |
VOID SetValue (IN UINT16 Value) { | |
mEqIdVal->Value = Value; | |
} | |
}; | |
class CIfrEqIdList : public CIfrObj, public CIfrOpHeader { | |
private: | |
EFI_IFR_EQ_ID_VAL_LIST *mEqIdVList; | |
public: | |
CIfrEqIdList ( | |
IN UINT32 LineNo | |
) : CIfrObj (EFI_IFR_EQ_ID_VAL_LIST_OP, (CHAR8 **)NULL, sizeof (EFI_IFR_EQ_ID_VAL_LIST), TRUE), | |
CIfrOpHeader (EFI_IFR_EQ_ID_VAL_LIST_OP, &(GetObjBinAddr<EFI_IFR_EQ_ID_VAL_LIST>())->Header), mEqIdVList(GetObjBinAddr<EFI_IFR_EQ_ID_VAL_LIST>()) { | |
SetLineNo (LineNo); | |
mEqIdVList->QuestionId = EFI_QUESTION_ID_INVALID; | |
mEqIdVList->ListLength = 0; | |
mEqIdVList->ValueList[0] = 0; | |
} | |
VOID UpdateIfrBuffer ( | |
) { | |
_EMIT_PENDING_OBJ(); | |
mEqIdVList = GetObjBinAddr<EFI_IFR_EQ_ID_VAL_LIST>(); | |
UpdateHeader (&mEqIdVList->Header); | |
} | |
VOID SetQuestionId ( | |
IN EFI_QUESTION_ID QuestionId, | |
IN CHAR8 *VarIdStr, | |
IN UINT32 LineNo | |
) { | |
if (QuestionId != EFI_QUESTION_ID_INVALID) { | |
mEqIdVList->QuestionId = QuestionId; | |
} else { | |
gCFormPkg.AssignPending (VarIdStr, (VOID *)(&mEqIdVList->QuestionId), sizeof (EFI_QUESTION_ID), LineNo, NO_QST_REFED); | |
} | |
} | |
VOID SetListLength (IN UINT16 ListLength) { | |
mEqIdVList->ListLength = ListLength; | |
} | |
VOID SetValueList (IN UINT16 Index, IN UINT16 Value) { | |
if (Index == 0) { | |
mEqIdVList->ValueList[0] = Value; | |
return; | |
} | |
if (ExpendObjBin (sizeof (UINT16)) ==TRUE) { | |
IncLength (sizeof (UINT16)); | |
mEqIdVList->ValueList[Index] = Value; | |
} | |
} | |
}; | |
class CIfrQuestionRef1 : public CIfrObj, public CIfrOpHeader { | |
private: | |
EFI_IFR_QUESTION_REF1 *mQuestionRef1; | |
public: | |
CIfrQuestionRef1 ( | |
IN UINT32 LineNo | |
) : CIfrObj (EFI_IFR_QUESTION_REF1_OP), | |
CIfrOpHeader (EFI_IFR_QUESTION_REF1_OP, &(GetObjBinAddr<EFI_IFR_QUESTION_REF1>())->Header), mQuestionRef1(GetObjBinAddr<EFI_IFR_QUESTION_REF1>()) { | |
SetLineNo (LineNo); | |
mQuestionRef1->QuestionId = EFI_QUESTION_ID_INVALID; | |
} | |
VOID SetQuestionId ( | |
IN EFI_QUESTION_ID QuestionId, | |
IN CHAR8 *VarIdStr, | |
IN UINT32 LineNo | |
) { | |
if (QuestionId != EFI_QUESTION_ID_INVALID) { | |
mQuestionRef1->QuestionId = QuestionId; | |
} else { | |
gCFormPkg.AssignPending (VarIdStr, (VOID *)(&mQuestionRef1->QuestionId), sizeof (EFI_QUESTION_ID), LineNo, NO_QST_REFED); | |
} | |
} | |
}; | |
class CIfrQuestionRef2 : public CIfrObj, public CIfrOpHeader { | |
public: | |
CIfrQuestionRef2 ( | |
IN UINT32 LineNo | |
) : CIfrObj (EFI_IFR_QUESTION_REF2_OP), | |
CIfrOpHeader (EFI_IFR_QUESTION_REF2_OP, &(GetObjBinAddr<EFI_IFR_QUESTION_REF2>())->Header) { | |
SetLineNo (LineNo); | |
} | |
}; | |
class CIfrQuestionRef3 : public CIfrObj, public CIfrOpHeader { | |
public: | |
CIfrQuestionRef3 ( | |
IN UINT32 LineNo | |
) : CIfrObj (EFI_IFR_QUESTION_REF3_OP), | |
CIfrOpHeader (EFI_IFR_QUESTION_REF3_OP, &(GetObjBinAddr<EFI_IFR_QUESTION_REF3>())->Header) { | |
SetLineNo (LineNo); | |
} | |
}; | |
class CIfrQuestionRef3_2 : public CIfrObj, public CIfrOpHeader { | |
private: | |
EFI_IFR_QUESTION_REF3_2 *mQuestionRef3_2; | |
public: | |
CIfrQuestionRef3_2 ( | |
IN UINT32 LineNo | |
) : CIfrObj (EFI_IFR_QUESTION_REF3_OP, (CHAR8 **)NULL, sizeof (EFI_IFR_QUESTION_REF3_2)), | |
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>()) { | |
SetLineNo (LineNo); | |
mQuestionRef3_2->DevicePath = EFI_STRING_ID_INVALID; | |
} | |
VOID SetDevicePath (IN EFI_STRING_ID DevicePath) { | |
mQuestionRef3_2->DevicePath = DevicePath; | |
} | |
}; | |
class CIfrQuestionRef3_3 : public CIfrObj, public CIfrOpHeader { | |
private: | |
EFI_IFR_QUESTION_REF3_3 *mQuestionRef3_3; | |
public: | |
CIfrQuestionRef3_3 ( | |
IN UINT32 LineNo | |
) : CIfrObj (EFI_IFR_QUESTION_REF3_OP, (CHAR8 **)NULL, sizeof (EFI_IFR_QUESTION_REF3_3)), | |
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>()) { | |
SetLineNo (LineNo); | |
mQuestionRef3_3->DevicePath = EFI_STRING_ID_INVALID; | |
memset (&mQuestionRef3_3->Guid, 0, sizeof (EFI_GUID)); | |
} | |
VOID SetDevicePath (IN EFI_STRING_ID DevicePath) { | |
mQuestionRef3_3->DevicePath = DevicePath; | |
} | |
VOID SetGuid (IN EFI_GUID *Guid) { | |
mQuestionRef3_3->Guid = *Guid; | |
} | |
}; | |
class CIfrRuleRef : public CIfrObj, public CIfrOpHeader { | |
private: | |
EFI_IFR_RULE_REF *mRuleRef; | |
public: | |
CIfrRuleRef ( | |
IN UINT32 LineNo | |
) : CIfrObj (EFI_IFR_RULE_REF_OP), | |
CIfrOpHeader (EFI_IFR_RULE_REF_OP, &(GetObjBinAddr<EFI_IFR_RULE_REF>())->Header), mRuleRef(GetObjBinAddr<EFI_IFR_RULE_REF>()) { | |
SetLineNo (LineNo); | |
mRuleRef->RuleId = EFI_RULE_ID_INVALID; | |
} | |
VOID SetRuleId (IN UINT8 RuleId) { | |
mRuleRef->RuleId = RuleId; | |
} | |
}; | |
class CIfrStringRef1 : public CIfrObj, public CIfrOpHeader { | |
private: | |
EFI_IFR_STRING_REF1 *mStringRef1; | |
public: | |
CIfrStringRef1 ( | |
IN UINT32 LineNo | |
) : CIfrObj (EFI_IFR_STRING_REF1_OP), | |
CIfrOpHeader (EFI_IFR_STRING_REF1_OP, &(GetObjBinAddr<EFI_IFR_STRING_REF1>())->Header), mStringRef1(GetObjBinAddr<EFI_IFR_STRING_REF1>()) { | |
SetLineNo (LineNo); | |
mStringRef1->StringId = EFI_STRING_ID_INVALID; | |
} | |
VOID SetStringId (IN EFI_STRING_ID StringId) { | |
mStringRef1->StringId = StringId; | |
} | |
}; | |
class CIfrStringRef2 : public CIfrObj, public CIfrOpHeader { | |
public: | |
CIfrStringRef2 ( | |
IN UINT32 LineNo | |
) : CIfrObj (EFI_IFR_STRING_REF2_OP), | |
CIfrOpHeader (EFI_IFR_STRING_REF2_OP, &(GetObjBinAddr<EFI_IFR_STRING_REF2>())->Header) { | |
SetLineNo (LineNo); | |
} | |
}; | |
class CIfrThis : public CIfrObj, public CIfrOpHeader { | |
public: | |
CIfrThis ( | |
IN UINT32 LineNo | |
) : CIfrObj (EFI_IFR_THIS_OP), | |
CIfrOpHeader (EFI_IFR_THIS_OP, &(GetObjBinAddr<EFI_IFR_THIS>())->Header) { | |
SetLineNo (LineNo); | |
} | |
}; | |
class CIfrSecurity : public CIfrObj, public CIfrOpHeader { | |
private: | |
EFI_IFR_SECURITY *mSecurity; | |
public: | |
CIfrSecurity ( | |
IN UINT32 LineNo | |
) : CIfrObj (EFI_IFR_SECURITY_OP), | |
CIfrOpHeader (EFI_IFR_SECURITY_OP, &(GetObjBinAddr<EFI_IFR_SECURITY>())->Header), mSecurity(GetObjBinAddr<EFI_IFR_SECURITY>()) { | |
SetLineNo (LineNo); | |
memset (&mSecurity->Permissions, 0, sizeof (EFI_GUID)); | |
} | |
VOID SetPermissions (IN EFI_GUID *Permissions) { | |
memmove (&mSecurity->Permissions, Permissions, sizeof (EFI_GUID)); | |
} | |
}; | |
class CIfrUint8 : public CIfrObj, public CIfrOpHeader { | |
private: | |
EFI_IFR_UINT8 *mUint8; | |
public: | |
CIfrUint8 ( | |
IN UINT32 LineNo | |
) : CIfrObj (EFI_IFR_UINT8_OP), | |
CIfrOpHeader (EFI_IFR_UINT8_OP, &(GetObjBinAddr<EFI_IFR_UINT8>())->Header), mUint8(GetObjBinAddr<EFI_IFR_UINT8>()) { | |
SetLineNo (LineNo); | |
} | |
VOID SetValue (IN UINT8 Value) { | |
mUint8->Value = Value; | |
} | |
}; | |
class CIfrUint16 : public CIfrObj, public CIfrOpHeader { | |
private: | |
EFI_IFR_UINT16 *mUint16; | |
public: | |
CIfrUint16 ( | |
IN UINT32 LineNo | |
) : CIfrObj (EFI_IFR_UINT16_OP), | |
CIfrOpHeader (EFI_IFR_UINT16_OP, &(GetObjBinAddr<EFI_IFR_UINT16>())->Header), mUint16(GetObjBinAddr<EFI_IFR_UINT16>()) { | |
SetLineNo (LineNo); | |
} | |
VOID SetValue (IN UINT16 Value) { | |
mUint16->Value = Value; | |
} | |
}; | |
class CIfrUint32 : public CIfrObj, public CIfrOpHeader { | |
private: | |
EFI_IFR_UINT32 *mUint32; | |
public: | |
CIfrUint32 ( | |
IN UINT32 LineNo | |
) : CIfrObj (EFI_IFR_UINT32_OP), | |
CIfrOpHeader (EFI_IFR_UINT32_OP, &(GetObjBinAddr<EFI_IFR_UINT32>())->Header), mUint32(GetObjBinAddr<EFI_IFR_UINT32>()) { | |
SetLineNo (LineNo); | |
} | |
VOID SetValue (IN UINT32 Value) { | |
mUint32->Value = Value; | |
} | |
}; | |
class CIfrUint64 : public CIfrObj, public CIfrOpHeader { | |
private: | |
EFI_IFR_UINT64 *mUint64; | |
public: | |
CIfrUint64 ( | |
IN UINT32 LineNo | |
) : CIfrObj (EFI_IFR_UINT64_OP), | |
CIfrOpHeader (EFI_IFR_UINT64_OP, &(GetObjBinAddr<EFI_IFR_UINT64>())->Header), mUint64(GetObjBinAddr<EFI_IFR_UINT64>()) { | |
SetLineNo (LineNo); | |
} | |
VOID SetValue (IN UINT64 Value) { | |
mUint64->Value = Value; | |
} | |
}; | |
class CIfrTrue : public CIfrObj, public CIfrOpHeader { | |
public: | |
CIfrTrue ( | |
IN UINT32 LineNo | |
) : CIfrObj (EFI_IFR_TRUE_OP), | |
CIfrOpHeader (EFI_IFR_TRUE_OP, &(GetObjBinAddr<EFI_IFR_TRUE>())->Header) { | |
SetLineNo (LineNo); | |
} | |
}; | |
class CIfrFalse : public CIfrObj, public CIfrOpHeader { | |
public: | |
CIfrFalse ( | |
IN UINT32 LineNo | |
) : CIfrObj (EFI_IFR_FALSE_OP), | |
CIfrOpHeader (EFI_IFR_FALSE_OP, &(GetObjBinAddr<EFI_IFR_FALSE>())->Header) { | |
SetLineNo (LineNo); | |
} | |
}; | |
class CIfrOne : public CIfrObj, public CIfrOpHeader { | |
public: | |
CIfrOne ( | |
IN UINT32 LineNo | |
) : CIfrObj (EFI_IFR_ONE_OP), | |
CIfrOpHeader (EFI_IFR_ONE_OP, &(GetObjBinAddr<EFI_IFR_ONE>())->Header) { | |
SetLineNo (LineNo); | |
} | |
}; | |
class CIfrOnes : public CIfrObj, public CIfrOpHeader { | |
public: | |
CIfrOnes ( | |
IN UINT32 LineNo | |
) : CIfrObj (EFI_IFR_ONES_OP), | |
CIfrOpHeader (EFI_IFR_ONES_OP, &(GetObjBinAddr<EFI_IFR_ONES>())->Header) { | |
SetLineNo (LineNo); | |
} | |
}; | |
class CIfrZero : public CIfrObj, public CIfrOpHeader { | |
public: | |
CIfrZero ( | |
IN UINT32 LineNo | |
) : CIfrObj (EFI_IFR_ZERO_OP), | |
CIfrOpHeader (EFI_IFR_ZERO_OP, &(GetObjBinAddr<EFI_IFR_ZERO>())->Header) { | |
SetLineNo (LineNo); | |
} | |
}; | |
class CIfrUndefined : public CIfrObj, public CIfrOpHeader { | |
public: | |
CIfrUndefined ( | |
IN UINT32 LineNo | |
) : CIfrObj (EFI_IFR_UNDEFINED_OP), | |
CIfrOpHeader (EFI_IFR_UNDEFINED_OP, &(GetObjBinAddr<EFI_IFR_UNDEFINED>())->Header) { | |
SetLineNo (LineNo); | |
} | |
}; | |
class CIfrVersion : public CIfrObj, public CIfrOpHeader { | |
public: | |
CIfrVersion ( | |
IN UINT32 LineNo | |
) : CIfrObj (EFI_IFR_VERSION_OP), | |
CIfrOpHeader (EFI_IFR_VERSION_OP, &(GetObjBinAddr<EFI_IFR_VERSION>())->Header) { | |
SetLineNo (LineNo); | |
} | |
}; | |
class CIfrLength : public CIfrObj, public CIfrOpHeader { | |
public: | |
CIfrLength ( | |
IN UINT32 LineNo | |
) : CIfrObj (EFI_IFR_LENGTH_OP), | |
CIfrOpHeader (EFI_IFR_LENGTH_OP, &(GetObjBinAddr<EFI_IFR_LENGTH>())->Header) { | |
SetLineNo (LineNo); | |
} | |
}; | |
class CIfrNot : public CIfrObj, public CIfrOpHeader { | |
public: | |
CIfrNot ( | |
IN UINT32 LineNo | |
) : CIfrObj (EFI_IFR_NOT_OP), | |
CIfrOpHeader (EFI_IFR_NOT_OP, &(GetObjBinAddr<EFI_IFR_NOT>())->Header) { | |
SetLineNo (LineNo); | |
} | |
}; | |
class CIfrBitWiseNot : public CIfrObj, public CIfrOpHeader { | |
public: | |
CIfrBitWiseNot ( | |
IN UINT32 LineNo | |
) : CIfrObj (EFI_IFR_BITWISE_NOT_OP), | |
CIfrOpHeader (EFI_IFR_BITWISE_NOT_OP, &(GetObjBinAddr<EFI_IFR_BITWISE_NOT>())->Header) { | |
SetLineNo (LineNo); | |
} | |
}; | |
class CIfrToBoolean : public CIfrObj, public CIfrOpHeader { | |
public: | |
CIfrToBoolean ( | |
IN UINT32 LineNo | |
) : CIfrObj (EFI_IFR_TO_BOOLEAN_OP), | |
CIfrOpHeader (EFI_IFR_TO_BOOLEAN_OP, &(GetObjBinAddr<EFI_IFR_TO_BOOLEAN>())->Header) { | |
SetLineNo (LineNo); | |
} | |
}; | |
class CIfrToString : public CIfrObj, public CIfrOpHeader { | |
private: | |
EFI_IFR_TO_STRING *mToString; | |
public: | |
CIfrToString ( | |
IN UINT32 LineNo | |
) : CIfrObj (EFI_IFR_TO_STRING_OP), | |
CIfrOpHeader (EFI_IFR_TO_STRING_OP, &(GetObjBinAddr<EFI_IFR_TO_STRING>())->Header), mToString(GetObjBinAddr<EFI_IFR_TO_STRING>()) { | |
SetLineNo (LineNo); | |
} | |
VOID SetFormat (IN UINT8 Format) { | |
mToString->Format = Format; | |
} | |
}; | |
class CIfrToUint : public CIfrObj, public CIfrOpHeader { | |
public: | |
CIfrToUint ( | |
IN UINT32 LineNo | |
) : CIfrObj (EFI_IFR_TO_UINT_OP), | |
CIfrOpHeader (EFI_IFR_TO_UINT_OP, &(GetObjBinAddr<EFI_IFR_TO_UINT>())->Header) { | |
SetLineNo (LineNo); | |
} | |
}; | |
class CIfrToUpper : public CIfrObj, public CIfrOpHeader { | |
public: | |
CIfrToUpper ( | |
IN UINT32 LineNo | |
) : CIfrObj (EFI_IFR_TO_UPPER_OP), | |
CIfrOpHeader (EFI_IFR_TO_UPPER_OP, &(GetObjBinAddr<EFI_IFR_TO_UPPER>())->Header) { | |
SetLineNo (LineNo); | |
} | |
}; | |
class CIfrToLower : public CIfrObj, public CIfrOpHeader { | |
public: | |
CIfrToLower ( | |
IN UINT32 LineNo | |
) : CIfrObj (EFI_IFR_TO_LOWER_OP), | |
CIfrOpHeader (EFI_IFR_TO_LOWER_OP, &(GetObjBinAddr<EFI_IFR_TO_LOWER>())->Header) { | |
SetLineNo (LineNo); | |
} | |
}; | |
class CIfrAdd : public CIfrObj, public CIfrOpHeader { | |
public: | |
CIfrAdd ( | |
IN UINT32 LineNo | |
) : CIfrObj (EFI_IFR_ADD_OP), | |
CIfrOpHeader (EFI_IFR_ADD_OP, &(GetObjBinAddr<EFI_IFR_ADD>())->Header) { | |
SetLineNo (LineNo); | |
} | |
}; | |
class CIfrBitWiseAnd : public CIfrObj, public CIfrOpHeader { | |
public: | |
CIfrBitWiseAnd ( | |
IN UINT32 LineNo | |
) : CIfrObj (EFI_IFR_BITWISE_AND_OP), | |
CIfrOpHeader (EFI_IFR_BITWISE_AND_OP, &(GetObjBinAddr<EFI_IFR_BITWISE_AND>())->Header) { | |
SetLineNo(LineNo); | |
} | |
}; | |
class CIfrBitWiseOr : public CIfrObj, public CIfrOpHeader { | |
public: | |
CIfrBitWiseOr ( | |
IN UINT32 LineNo | |
) : CIfrObj (EFI_IFR_BITWISE_OR_OP), | |
CIfrOpHeader (EFI_IFR_BITWISE_OR_OP, &(GetObjBinAddr<EFI_IFR_BITWISE_OR>())->Header) { | |
SetLineNo (LineNo); | |
} | |
}; | |
class CIfrAnd : public CIfrObj, public CIfrOpHeader { | |
public: | |
CIfrAnd ( | |
IN UINT32 LineNo | |
) : CIfrObj (EFI_IFR_AND_OP), | |
CIfrOpHeader (EFI_IFR_AND_OP, &(GetObjBinAddr<EFI_IFR_AND>())->Header) { | |
SetLineNo (LineNo); | |
} | |
}; | |
class CIfrCatenate : public CIfrObj, public CIfrOpHeader { | |
public: | |
CIfrCatenate ( | |
IN UINT32 LineNo | |
) : CIfrObj (EFI_IFR_CATENATE_OP), | |
CIfrOpHeader (EFI_IFR_CATENATE_OP, &(GetObjBinAddr<EFI_IFR_CATENATE>())->Header) { | |
SetLineNo (LineNo); | |
} | |
}; | |
class CIfrDivide : public CIfrObj, public CIfrOpHeader { | |
public: | |
CIfrDivide ( | |
IN UINT32 LineNo | |
) : CIfrObj (EFI_IFR_DIVIDE_OP), | |
CIfrOpHeader (EFI_IFR_DIVIDE_OP, &(GetObjBinAddr<EFI_IFR_DIVIDE>())->Header) { | |
SetLineNo (LineNo); | |
} | |
}; | |
class CIfrEqual : public CIfrObj, public CIfrOpHeader { | |
public: | |
CIfrEqual ( | |
IN UINT32 LineNo | |
) : CIfrObj (EFI_IFR_EQUAL_OP), | |
CIfrOpHeader (EFI_IFR_EQUAL_OP, &(GetObjBinAddr<EFI_IFR_EQUAL>())->Header) { | |
SetLineNo (LineNo); | |
} | |
}; | |
class CIfrGreaterEqual : public CIfrObj, public CIfrOpHeader { | |
public: | |
CIfrGreaterEqual ( | |
IN UINT32 LineNo | |
) : CIfrObj (EFI_IFR_GREATER_EQUAL_OP), | |
CIfrOpHeader (EFI_IFR_GREATER_EQUAL_OP, &(GetObjBinAddr<EFI_IFR_GREATER_EQUAL>())->Header) { | |
SetLineNo (LineNo); | |
} | |
}; | |
class CIfrGreaterThan : public CIfrObj, public CIfrOpHeader { | |
public: | |
CIfrGreaterThan ( | |
IN UINT32 LineNo | |
) : CIfrObj (EFI_IFR_GREATER_THAN_OP), | |
CIfrOpHeader (EFI_IFR_GREATER_THAN_OP, &(GetObjBinAddr<EFI_IFR_GREATER_THAN>())->Header) { | |
SetLineNo (LineNo); | |
} | |
}; | |
class CIfrLessEqual : public CIfrObj, public CIfrOpHeader { | |
public: | |
CIfrLessEqual ( | |
IN UINT32 LineNo | |
) : CIfrObj (EFI_IFR_LESS_EQUAL_OP), | |
CIfrOpHeader (EFI_IFR_LESS_EQUAL_OP, &(GetObjBinAddr<EFI_IFR_LESS_EQUAL>())->Header) { | |
SetLineNo (LineNo); | |
} | |
}; | |
class CIfrLessThan : public CIfrObj, public CIfrOpHeader { | |
public: | |
CIfrLessThan ( | |
IN UINT32 LineNo | |
) : CIfrObj (EFI_IFR_LESS_THAN_OP), | |
CIfrOpHeader (EFI_IFR_LESS_THAN_OP, &(GetObjBinAddr<EFI_IFR_LESS_THAN>())->Header) { | |
SetLineNo (LineNo); | |
} | |
}; | |
class CIfrMap : public CIfrObj, public CIfrOpHeader{ | |
public: | |
CIfrMap ( | |
IN UINT32 LineNo | |
) : CIfrObj (EFI_IFR_MAP_OP), | |
CIfrOpHeader (EFI_IFR_MAP_OP, &(GetObjBinAddr<EFI_IFR_MAP>())->Header) { | |
SetLineNo (LineNo); | |
} | |
}; | |
class CIfrMatch : public CIfrObj, public CIfrOpHeader { | |
public: | |
CIfrMatch ( | |
IN UINT32 LineNo | |
) : CIfrObj (EFI_IFR_MATCH_OP), | |
CIfrOpHeader (EFI_IFR_MATCH_OP, &(GetObjBinAddr<EFI_IFR_MATCH>())->Header) { | |
SetLineNo (LineNo); | |
} | |
}; | |
class CIfrMatch2 : public CIfrObj, public CIfrOpHeader { | |
private: | |
EFI_IFR_MATCH2 *mMatch2; | |
public: | |
CIfrMatch2 ( | |
IN UINT32 LineNo, | |
IN EFI_GUID *Guid | |
) : CIfrObj (EFI_IFR_MATCH2_OP), | |
CIfrOpHeader (EFI_IFR_MATCH2_OP, &(GetObjBinAddr<EFI_IFR_MATCH2>())->Header), mMatch2(GetObjBinAddr<EFI_IFR_MATCH2>()) { | |
SetLineNo (LineNo); | |
memmove (&mMatch2->SyntaxType, Guid, sizeof (EFI_GUID)); | |
} | |
}; | |
class CIfrMultiply : public CIfrObj, public CIfrOpHeader { | |
public: | |
CIfrMultiply ( | |
IN UINT32 LineNo | |
) : CIfrObj (EFI_IFR_MULTIPLY_OP), | |
CIfrOpHeader (EFI_IFR_MULTIPLY_OP, &(GetObjBinAddr<EFI_IFR_MULTIPLY>())->Header) { | |
SetLineNo (LineNo); | |
} | |
}; | |
class CIfrModulo : public CIfrObj, public CIfrOpHeader { | |
public: | |
CIfrModulo ( | |
IN UINT32 LineNo | |
) : CIfrObj (EFI_IFR_MODULO_OP), | |
CIfrOpHeader (EFI_IFR_MODULO_OP, &(GetObjBinAddr<EFI_IFR_MODULO>())->Header) { | |
SetLineNo (LineNo); | |
} | |
}; | |
class CIfrNotEqual : public CIfrObj, public CIfrOpHeader { | |
public: | |
CIfrNotEqual ( | |
IN UINT32 LineNo | |
) : CIfrObj (EFI_IFR_NOT_EQUAL_OP), | |
CIfrOpHeader (EFI_IFR_NOT_EQUAL_OP, &(GetObjBinAddr<EFI_IFR_NOT_EQUAL>())->Header) { | |
SetLineNo (LineNo); | |
} | |
}; | |
class CIfrOr : public CIfrObj, public CIfrOpHeader { | |
public: | |
CIfrOr ( | |
IN UINT32 LineNo | |
) : CIfrObj (EFI_IFR_OR_OP), | |
CIfrOpHeader (EFI_IFR_OR_OP, &(GetObjBinAddr<EFI_IFR_OR>())->Header) { | |
SetLineNo (LineNo); | |
} | |
}; | |
class CIfrShiftLeft : public CIfrObj, public CIfrOpHeader { | |
public: | |
CIfrShiftLeft ( | |
IN UINT32 LineNo | |
) : CIfrObj (EFI_IFR_SHIFT_LEFT_OP), | |
CIfrOpHeader (EFI_IFR_SHIFT_LEFT_OP, &(GetObjBinAddr<EFI_IFR_SHIFT_LEFT>())->Header) { | |
SetLineNo (LineNo); | |
} | |
}; | |
class CIfrShiftRight : public CIfrObj, public CIfrOpHeader { | |
public: | |
CIfrShiftRight ( | |
IN UINT32 LineNo | |
) : CIfrObj (EFI_IFR_SHIFT_RIGHT_OP), | |
CIfrOpHeader (EFI_IFR_SHIFT_RIGHT_OP, &(GetObjBinAddr<EFI_IFR_SHIFT_RIGHT>())->Header) { | |
SetLineNo (LineNo); | |
} | |
}; | |
class CIfrSubtract : public CIfrObj, public CIfrOpHeader { | |
public: | |
CIfrSubtract ( | |
IN UINT32 LineNo | |
) : CIfrObj (EFI_IFR_SUBTRACT_OP), | |
CIfrOpHeader (EFI_IFR_SUBTRACT_OP, &(GetObjBinAddr<EFI_IFR_SUBTRACT>())->Header) { | |
SetLineNo (LineNo); | |
} | |
}; | |
class CIfrConditional : public CIfrObj, public CIfrOpHeader { | |
public: | |
CIfrConditional ( | |
IN UINT32 LineNo | |
) : CIfrObj (EFI_IFR_CONDITIONAL_OP), | |
CIfrOpHeader (EFI_IFR_CONDITIONAL_OP, &(GetObjBinAddr<EFI_IFR_CONDITIONAL>())->Header) { | |
SetLineNo (LineNo); | |
} | |
}; | |
class CIfrFind : public CIfrObj, public CIfrOpHeader { | |
private: | |
EFI_IFR_FIND *mFind; | |
public: | |
CIfrFind ( | |
IN UINT32 LineNo | |
) : CIfrObj (EFI_IFR_FIND_OP), | |
CIfrOpHeader (EFI_IFR_FIND_OP, &(GetObjBinAddr<EFI_IFR_FIND>())->Header), mFind(GetObjBinAddr<EFI_IFR_FIND>()) { | |
SetLineNo (LineNo); | |
} | |
VOID SetFormat (IN UINT8 Format) { | |
mFind->Format = Format; | |
} | |
}; | |
class CIfrMid : public CIfrObj, public CIfrOpHeader { | |
public: | |
CIfrMid ( | |
IN UINT32 LineNo | |
) : CIfrObj (EFI_IFR_MID_OP), | |
CIfrOpHeader (EFI_IFR_MID_OP, &(GetObjBinAddr<EFI_IFR_MID>())->Header) { | |
SetLineNo (LineNo); | |
} | |
}; | |
class CIfrToken : public CIfrObj, public CIfrOpHeader { | |
public: | |
CIfrToken ( | |
IN UINT32 LineNo | |
) : CIfrObj (EFI_IFR_TOKEN_OP), | |
CIfrOpHeader (EFI_IFR_TOKEN_OP, &(GetObjBinAddr<EFI_IFR_TOKEN>())->Header) { | |
SetLineNo (LineNo); | |
} | |
}; | |
class CIfrSpan : public CIfrObj, public CIfrOpHeader { | |
private: | |
EFI_IFR_SPAN *mSpan; | |
public: | |
CIfrSpan ( | |
IN UINT32 LineNo | |
) : CIfrObj (EFI_IFR_SPAN_OP), | |
CIfrOpHeader (EFI_IFR_SPAN_OP, &(GetObjBinAddr<EFI_IFR_SPAN>())->Header), mSpan(GetObjBinAddr<EFI_IFR_SPAN>()) { | |
SetLineNo (LineNo); | |
mSpan->Flags = EFI_IFR_FLAGS_FIRST_MATCHING; | |
} | |
EFI_VFR_RETURN_CODE SetFlags (IN UINT8 LFlags) { | |
if (_IS_EQUAL (LFlags, EFI_IFR_FLAGS_FIRST_MATCHING)) { | |
mSpan->Flags |= EFI_IFR_FLAGS_FIRST_MATCHING; | |
} else if (_FLAG_TEST_AND_CLEAR (LFlags, EFI_IFR_FLAGS_FIRST_NON_MATCHING)) { | |
mSpan->Flags |= EFI_IFR_FLAGS_FIRST_NON_MATCHING; | |
} | |
return _FLAGS_ZERO (LFlags) ? VFR_RETURN_SUCCESS : VFR_RETURN_FLAGS_UNSUPPORTED; | |
} | |
}; | |
#endif |