From f215e02bf85f68d3a6106c2a1f4f7f063f819064 Mon Sep 17 00:00:00 2001 From: Daniel Baumann Date: Thu, 11 Apr 2024 10:17:27 +0200 Subject: Adding upstream version 7.0.14-dfsg. Signed-off-by: Daniel Baumann --- .../BaseTools/Source/C/VfrCompile/VfrFormPkg.h | 2776 ++++++++++++++++++++ 1 file changed, 2776 insertions(+) create mode 100644 src/VBox/Devices/EFI/Firmware/BaseTools/Source/C/VfrCompile/VfrFormPkg.h (limited to 'src/VBox/Devices/EFI/Firmware/BaseTools/Source/C/VfrCompile/VfrFormPkg.h') diff --git a/src/VBox/Devices/EFI/Firmware/BaseTools/Source/C/VfrCompile/VfrFormPkg.h b/src/VBox/Devices/EFI/Firmware/BaseTools/Source/C/VfrCompile/VfrFormPkg.h new file mode 100644 index 00000000..d412de12 --- /dev/null +++ b/src/VBox/Devices/EFI/Firmware/BaseTools/Source/C/VfrCompile/VfrFormPkg.h @@ -0,0 +1,2776 @@ +/** @file + + The definition of CFormPkg's member function + +Copyright (c) 2004 - 2019, Intel Corporation. All rights reserved.
+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 + inline T * GetObjBinAddr (VOID) { + return reinterpret_cast(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())->Header, Size), mFormSet(GetObjBinAddr()) { + 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())->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())->Header), mDefaultStore(GetObjBinAddr()) { + 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())->Header), mForm(GetObjBinAddr()) { + 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())->Header), mFormMap(GetObjBinAddr()) { + 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())->Header), mVarStore(GetObjBinAddr()) { + 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())->Header), mVarStoreEfi(GetObjBinAddr()) { + 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())->Header), mVarStoreNameValue(GetObjBinAddr()) { + 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())->Header), mImage(GetObjBinAddr()) { + 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())->Header) { + } +}; + + +class CIfrLocked : public CIfrObj, public CIfrOpHeader { +public: + CIfrLocked () : CIfrObj (EFI_IFR_LOCKED_OP), + CIfrOpHeader (EFI_IFR_LOCKED_OP, &(GetObjBinAddr())->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())->Header), mRule(GetObjBinAddr()) { + 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())->Header, Size), mDefault(GetObjBinAddr()) { + 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())->Header, sizeof (EFI_IFR_DEFAULT_2)), mDefault(GetObjBinAddr()) { + 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())->Header) {} + +}; + +class CIfrRead : public CIfrObj, public CIfrOpHeader{ +public: + CIfrRead () : CIfrObj (EFI_IFR_READ_OP), + CIfrOpHeader (EFI_IFR_READ_OP, &(GetObjBinAddr())->Header) {} + +}; + +class CIfrWrite : public CIfrObj, public CIfrOpHeader{ +public: + CIfrWrite () : CIfrObj (EFI_IFR_WRITE_OP), + CIfrOpHeader (EFI_IFR_WRITE_OP, &(GetObjBinAddr())->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())->Header), mGet(GetObjBinAddr()) { + 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())->Header), mSet(GetObjBinAddr()) { + 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())->Header), + CIfrStatementHeader (&(GetObjBinAddr())->Statement), mSubtitle(GetObjBinAddr()) { + 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())->Header), + CIfrStatementHeader (&(GetObjBinAddr())->Statement), mText(GetObjBinAddr()) { + 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())->Header), + CIfrQuestionHeader (&(GetObjBinAddr())->Question), mRef(GetObjBinAddr()) { + 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())->Header, sizeof (EFI_IFR_REF2)), + CIfrQuestionHeader (&(GetObjBinAddr())->Question), mRef2(GetObjBinAddr()) { + 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())->Header, sizeof (EFI_IFR_REF3)), + CIfrQuestionHeader (&(GetObjBinAddr())->Question), mRef3(GetObjBinAddr()) { + 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())->Header, sizeof(EFI_IFR_REF4)), + CIfrQuestionHeader (&(GetObjBinAddr())->Question), mRef4(GetObjBinAddr()) { + 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())->Header, sizeof (EFI_IFR_REF5)), + CIfrQuestionHeader (&(GetObjBinAddr())->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())->Header), + CIfrStatementHeader (&(GetObjBinAddr())->Statement), mResetButton(GetObjBinAddr()) { + 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())->Header), + CIfrQuestionHeader (&(GetObjBinAddr())->Question), mCheckBox(GetObjBinAddr()) { + 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())->Header), + CIfrQuestionHeader (&(GetObjBinAddr())->Question), mAction(GetObjBinAddr()) { + 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())->Header), + CIfrQuestionHeader (&(GetObjBinAddr())->Question), mDate(GetObjBinAddr()) { + 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())->Header), + CIfrQuestionHeader (&(GetObjBinAddr())->Question), + CIfrMinMaxStepData (&(GetObjBinAddr())->data, TRUE), mNumeric(GetObjBinAddr()) { + 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(); + 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())->Header), + CIfrQuestionHeader (&(GetObjBinAddr())->Question), + CIfrMinMaxStepData (&(GetObjBinAddr())->data), mOneOf(GetObjBinAddr()) { + 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 & EFI_IFR_DISPLAY) { + 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(); + 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())->Header), + CIfrQuestionHeader (&(GetObjBinAddr())->Question), mString(GetObjBinAddr()) { + 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())->Header), + CIfrQuestionHeader (&(GetObjBinAddr())->Question), mPassword(GetObjBinAddr()) { + 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())->Header), + CIfrQuestionHeader (&(GetObjBinAddr())->Question), mOrderedList(GetObjBinAddr()) { + 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())->Header), + CIfrQuestionHeader (&(GetObjBinAddr())->Question), mTime(GetObjBinAddr()) { + 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())->Header) {} +}; + +class CIfrSuppressIf : public CIfrObj, public CIfrOpHeader { +public: + CIfrSuppressIf () : CIfrObj (EFI_IFR_SUPPRESS_IF_OP), + CIfrOpHeader (EFI_IFR_SUPPRESS_IF_OP, &(GetObjBinAddr())->Header) {} +}; + +class CIfrGrayOutIf : public CIfrObj, public CIfrOpHeader { +public: + CIfrGrayOutIf () : CIfrObj (EFI_IFR_GRAY_OUT_IF_OP), + CIfrOpHeader (EFI_IFR_GRAY_OUT_IF_OP, &(GetObjBinAddr())->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())->Header), mInconsistentIf(GetObjBinAddr()) { + 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())->Header), mWarningIf(GetObjBinAddr()) { + 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())->Header), mNoSubmitIf(GetObjBinAddr()) { + 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())->Header), mRefresh(GetObjBinAddr()) { + 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())->Header), mRefreshId(GetObjBinAddr()) { + 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())->Header), mVarStoreDevice(GetObjBinAddr()) { + 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())->Header, Size), mOneOfOption(GetObjBinAddr()) { + 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())->Header, sizeof (EFI_IFR_GUID_CLASS)), mClass(GetObjBinAddr()) { + 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())->Header, sizeof (EFI_IFR_GUID_SUBCLASS)), mSubClass(GetObjBinAddr()) { + 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())->Header, sizeof (EFI_IFR_GUID_LABEL)), mLabel(GetObjBinAddr()) { + 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())->Header, sizeof (EFI_IFR_GUID_BANNER)), mBanner(GetObjBinAddr()) { + 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())->Header, sizeof (EFI_IFR_GUID_OPTIONKEY)), mOptionKey(GetObjBinAddr()) { + 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())->Header, sizeof (EFI_IFR_GUID_VAREQNAME)), mVarEqName(GetObjBinAddr()) { + 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())->Header, sizeof (EFI_IFR_GUID_TIMEOUT)), mTimeout(GetObjBinAddr()) { + 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())->Header, sizeof (EFI_IFR_GUID)+Size), mGuid(GetObjBinAddr()) { + 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())->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())->Header), mEqIdId(GetObjBinAddr()) { + 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())->Header), mEqIdVal(GetObjBinAddr()) { + 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())->Header), mEqIdVList(GetObjBinAddr()) { + SetLineNo (LineNo); + mEqIdVList->QuestionId = EFI_QUESTION_ID_INVALID; + mEqIdVList->ListLength = 0; + mEqIdVList->ValueList[0] = 0; + } + + VOID UpdateIfrBuffer ( + ) { + _EMIT_PENDING_OBJ(); + mEqIdVList = GetObjBinAddr(); + 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())->Header), mQuestionRef1(GetObjBinAddr()) { + 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())->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())->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())->Header, sizeof (EFI_IFR_QUESTION_REF3_2)), mQuestionRef3_2(GetObjBinAddr()) { + 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())->Header, sizeof (EFI_IFR_QUESTION_REF3_3)), mQuestionRef3_3(GetObjBinAddr()) { + 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())->Header), mRuleRef(GetObjBinAddr()) { + 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())->Header), mStringRef1(GetObjBinAddr()) { + 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())->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())->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())->Header), mSecurity(GetObjBinAddr()) { + 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())->Header), mUint8(GetObjBinAddr()) { + 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())->Header), mUint16(GetObjBinAddr()) { + 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())->Header), mUint32(GetObjBinAddr()) { + 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())->Header), mUint64(GetObjBinAddr()) { + 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())->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())->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())->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())->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())->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())->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())->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())->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())->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())->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())->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())->Header), mToString(GetObjBinAddr()) { + 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())->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())->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())->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())->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())->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())->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())->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())->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())->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())->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())->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())->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())->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())->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())->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())->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())->Header), mMatch2(GetObjBinAddr()) { + 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())->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())->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())->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())->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())->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())->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())->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())->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())->Header), mFind(GetObjBinAddr()) { + 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())->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())->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())->Header), mSpan(GetObjBinAddr()) { + 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 -- cgit v1.2.3