X-Git-Url: https://git.proxmox.com/?p=mirror_edk2.git;a=blobdiff_plain;f=BaseTools%2FSource%2FC%2FVfrCompile%2FVfrFormPkg.h;h=822f861983f8c77a1fc4969032dfcd452645ba81;hp=3f387666bd50d9d03abc0cd7b48945f0641b9ceb;hb=5397bd425eba0cd00c5f76c8d35f328ca625db0e;hpb=30fdf1140b8d1ce93f3821d986fa165552023440
diff --git a/BaseTools/Source/C/VfrCompile/VfrFormPkg.h b/BaseTools/Source/C/VfrCompile/VfrFormPkg.h
index 3f387666bd..822f861983 100644
--- a/BaseTools/Source/C/VfrCompile/VfrFormPkg.h
+++ b/BaseTools/Source/C/VfrCompile/VfrFormPkg.h
@@ -2,8 +2,8 @@
The definition of CFormPkg's member function
-Copyright (c) 2004 - 2008, Intel Corporation
-All rights reserved. This program and the accompanying materials
+Copyright (c) 2004 - 2017, Intel Corporation. All rights reserved.
+This program and the accompanying materials
are licensed and made available under the terms and conditions of the BSD License
which accompanies this distribution. The full text of the license may be found at
http://opensource.org/licenses/bsd-license.php
@@ -81,12 +81,16 @@ struct SPendingAssign {
CHAR8 *mMsg;
struct SPendingAssign *mNext;
- SPendingAssign (IN CHAR8 *, IN VOID *, IN UINT32, IN UINT32, IN CHAR8 *);
+ 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 {
@@ -96,6 +100,11 @@ struct SBufferNode {
struct SBufferNode *mNext;
};
+typedef struct {
+ BOOLEAN CompatibleMode;
+ EFI_GUID *OverrideClassGuid;
+} INPUT_INFO_TO_SYNTAX;
+
class CFormPkg {
private:
UINT32 mBufferSize;
@@ -108,14 +117,18 @@ private:
UINT32 mPkgLength;
- VOID _WRITE_PKG_LINE (IN FILE *, IN UINT32 , IN CHAR8 *, IN CHAR8 *, IN UINT32);
- VOID _WRITE_PKG_END (IN FILE *, IN UINT32 , IN CHAR8 *, IN CHAR8 *, IN UINT32);
+ 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);
+ CFormPkg (IN UINT32 BufferSize = 4096);
~CFormPkg ();
CHAR8 * IfrBinBufferGet (IN UINT32);
@@ -130,8 +143,12 @@ public:
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 CHAR8 *Msg = NULL);
+ 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);
@@ -140,11 +157,23 @@ public:
IN CVfrDataStorage &lCVfrDataStorage,
IN CVfrQuestionDB &lCVfrQuestionDB,
IN EFI_GUID *LocalFormSetGuid,
- IN UINT32 LineNo
+ 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 CFormPkg gCFormPkg;
+extern CVfrStringDB gCVfrStringDB;
+extern UINT32 gAdjustOpcodeOffset;
+extern BOOLEAN gNeedAdjustOpcode;
struct SIfrRecord {
UINT32 mLineNo;
@@ -157,8 +186,23 @@ struct SIfrRecord {
~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:
@@ -166,6 +210,8 @@ private:
UINT32 mRecordCount;
SIfrRecord *mIfrRecordListHead;
SIfrRecord *mIfrRecordListTail;
+ UINT8 mAllDefaultTypeCount;
+ UINT16 mAllDefaultIdArray[EFI_HII_MAX_SUPPORT_DEFAULT_TYPE];
SIfrRecord * GetRecordInfoFromIdx (IN UINT32);
BOOLEAN CheckQuestionOpCode (IN UINT8);
@@ -183,11 +229,26 @@ public:
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);
+ 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;
@@ -195,11 +256,11 @@ extern CIfrRecordInfoDB gCIfrRecordInfoDB;
/*
* The definition of CIfrObj
*/
-extern bool gCreateOp;
+extern BOOLEAN gCreateOp;
class CIfrObj {
private:
- bool mDelayEmit;
+ BOOLEAN mDelayEmit;
CHAR8 *mObjBinBuf;
UINT8 mObjBinLen;
@@ -217,8 +278,13 @@ public:
mLineNo = LineNo;
}
- inline CHAR8 * GetObjBinAddr (VOID) {
- return mObjBinBuf;
+ template
+ inline T * GetObjBinAddr (VOID) {
+ return reinterpret_cast(mObjBinBuf);
+ }
+
+ inline UINT32 GetObjBinOffset (VOID) {
+ return mPkgOffset;
}
inline UINT8 GetObjBinLen (VOID) {
@@ -227,7 +293,16 @@ public:
inline bool ExpendObjBin (IN UINT8 Size) {
if ((mDelayEmit == TRUE) && ((mObjBinLen + Size) > mObjBinLen)) {
- mObjBinLen += Size;
+ 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;
@@ -245,16 +320,17 @@ private:
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 += Size;
+ mHeader->Length = mHeader->Length + Size;
}
}
VOID DecLength (UINT8 Size) {
if (mHeader->Length >= Size) {
- mHeader -= Size;
+ mHeader->Length -= Size;
}
}
@@ -273,6 +349,10 @@ public:
VOID UpdateHeader (IN EFI_IFR_OP_HEADER *Header) {
mHeader = Header;
}
+
+ UINT8 GetOpCode () {
+ return mHeader->OpCode;
+ }
};
extern UINT8 gScopeCount;
@@ -331,7 +411,7 @@ public:
VOID VARSTORE_INFO (OUT EFI_VARSTORE_INFO *Info) {
if (Info != NULL) {
Info->mVarStoreId = mHeader->VarStoreId;
- memcpy (&Info->mVarStoreId, &mHeader->VarStoreInfo, sizeof (Info->mVarStoreId));
+ memmove (&Info->mVarStoreId, &mHeader->VarStoreInfo, sizeof (Info->mVarStoreId));
}
}
@@ -358,7 +438,7 @@ public:
VOID SetVarStoreInfo (IN EFI_VARSTORE_INFO *Info) {
mHeader->VarStoreId = Info->mVarStoreId;
- mHeader->VarStoreInfo.VarName = Info->mInfo.mVarName;
+ mHeader->VarStoreInfo.VarName = Info->mInfo.mVarName;
mHeader->VarStoreInfo.VarOffset = Info->mInfo.mVarOffset;
}
@@ -381,7 +461,11 @@ public:
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
@@ -396,9 +480,11 @@ public:
return _FLAGS_ZERO (Flags) ? VFR_RETURN_SUCCESS : VFR_RETURN_FLAGS_UNSUPPORTED;
}
-};
-static CIfrQuestionHeader *gCurrentQuestion = NULL;
+ VOID UpdateCIfrQuestionHeader (IN EFI_IFR_QUESTION_HEADER *Header) {
+ mHeader = Header;
+ }
+};
/*
* The definition of CIfrMinMaxStepData
@@ -406,58 +492,191 @@ static CIfrQuestionHeader *gCurrentQuestion = NULL;
class CIfrMinMaxStepData {
private:
MINMAXSTEP_DATA *mMinMaxStepData;
+ BOOLEAN ValueIsSet;
+ BOOLEAN IsNumeric;
public:
- CIfrMinMaxStepData (MINMAXSTEP_DATA *DataAddr) : mMinMaxStepData (DataAddr) {
+ 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) {
- mMinMaxStepData->u64.MinValue = MinValue;
- mMinMaxStepData->u64.MaxValue = MaxValue;
- mMinMaxStepData->u64.Step = 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) {
- mMinMaxStepData->u32.MinValue = MinValue;
- mMinMaxStepData->u32.MaxValue = MaxValue;
- mMinMaxStepData->u32.Step = 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) {
- mMinMaxStepData->u16.MinValue = MinValue;
- mMinMaxStepData->u16.MaxValue = MaxValue;
- mMinMaxStepData->u16.Step = 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) {
- mMinMaxStepData->u8.MinValue = MinValue;
- mMinMaxStepData->u8.MaxValue = MaxValue;
- mMinMaxStepData->u8.Step = 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 **)&mFormSet, Size),
- CIfrOpHeader (EFI_IFR_FORM_SET_OP, &mFormSet->Header, Size) {
+ 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) {
- memcpy (&mFormSet->Guid, Guid, sizeof (EFI_GUID));
+ memmove (&mFormSet->Guid, Guid, sizeof (EFI_GUID));
}
VOID SetFormSetTitle (IN EFI_STRING_ID FormSetTitle) {
@@ -469,7 +688,7 @@ public:
}
VOID SetClassGuid (IN EFI_GUID *Guid) {
- memcpy (&(mFormSet->ClassGuid[mFormSet->Flags++]), Guid, sizeof (EFI_GUID));
+ memmove (&(mClassGuid[mFormSet->Flags++]), Guid, sizeof (EFI_GUID));
}
UINT8 GetFlags() {
@@ -478,12 +697,9 @@ public:
};
class CIfrEnd : public CIfrObj, public CIfrOpHeader {
-private:
- EFI_IFR_END *mEnd;
-
public:
- CIfrEnd () : CIfrObj (EFI_IFR_END_OP, (CHAR8 **)&mEnd),
- CIfrOpHeader (EFI_IFR_END_OP, &mEnd->Header) {}
+ CIfrEnd () : CIfrObj (EFI_IFR_END_OP),
+ CIfrOpHeader (EFI_IFR_END_OP, &(GetObjBinAddr())->Header) {}
};
class CIfrDefaultStore : public CIfrObj, public CIfrOpHeader {
@@ -491,8 +707,8 @@ private:
EFI_IFR_DEFAULTSTORE *mDefaultStore;
public:
- CIfrDefaultStore () : CIfrObj (EFI_IFR_DEFAULTSTORE_OP, (CHAR8 **)&mDefaultStore),
- CIfrOpHeader (EFI_IFR_DEFAULTSTORE_OP, &mDefaultStore->Header) {
+ 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;
}
@@ -509,10 +725,8 @@ public:
#define EFI_FORM_ID_MAX 0xFFFF
#define EFI_FREE_FORM_ID_BITMAP_SIZE ((EFI_FORM_ID_MAX + 1) / EFI_BITS_PER_UINT32)
-class CIfrForm : public CIfrObj, public CIfrOpHeader {
-private:
- EFI_IFR_FORM *mForm;
-
+class CIfrFormId {
+public:
STATIC UINT32 FormIdBitMap[EFI_FREE_FORM_ID_BITMAP_SIZE];
STATIC BOOLEAN ChekFormIdFree (IN EFI_FORM_ID FormId) {
@@ -528,20 +742,31 @@ private:
FormIdBitMap[Index] |= (0x80000000 >> Offset);
}
+};
+
+class CIfrForm : public CIfrObj, public CIfrOpHeader {
+private:
+ EFI_IFR_FORM *mForm;
public:
- CIfrForm () : CIfrObj (EFI_IFR_FORM_OP, (CHAR8 **)&mForm),
- CIfrOpHeader (EFI_IFR_FORM_OP, &mForm->Header) {
+ 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 (CIfrForm::ChekFormIdFree (FormId) == FALSE) {
+ 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;
- CIfrForm::MarkFormIdUsed (FormId);
+ CIfrFormId::MarkFormIdUsed (FormId);
return VFR_RETURN_SUCCESS;
}
@@ -550,13 +775,51 @@ public:
}
};
+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 **)&mVarStore, sizeof (EFI_IFR_VARSTORE), TRUE),
- CIfrOpHeader (EFI_IFR_VARSTORE_OP, &mVarStore->Header) {
+ 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));
@@ -564,7 +827,7 @@ public:
}
VOID SetGuid (IN EFI_GUID *Guid) {
- memcpy (&mVarStore->Guid, Guid, sizeof (EFI_GUID));
+ memmove (&mVarStore->Guid, Guid, sizeof (EFI_GUID));
}
VOID SetVarStoreId (IN EFI_VARSTORE_ID VarStoreId) {
@@ -579,7 +842,7 @@ public:
UINT8 Len;
if (Name != NULL) {
- Len = strlen (Name);
+ Len = (UINT8) strlen (Name);
if (Len != 0) {
if (ExpendObjBin (Len) == TRUE) {
IncLength (Len);
@@ -595,14 +858,16 @@ private:
EFI_IFR_VARSTORE_EFI *mVarStoreEfi;
public:
- CIfrVarStoreEfi () : CIfrObj (EFI_IFR_VARSTORE_EFI_OP, (CHAR8 **)&mVarStoreEfi),
- CIfrOpHeader (EFI_IFR_VARSTORE_EFI_OP, &mVarStoreEfi->Header) {
+ 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) {
- memcpy (&mVarStoreEfi->Guid, Guid, sizeof (EFI_GUID));
+ memmove (&mVarStoreEfi->Guid, Guid, sizeof (EFI_GUID));
}
VOID SetVarStoreId (IN UINT16 VarStoreId) {
@@ -612,6 +877,36 @@ public:
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 {
@@ -619,14 +914,14 @@ private:
EFI_IFR_VARSTORE_NAME_VALUE *mVarStoreNameValue;
public:
- CIfrVarStoreNameValue () : CIfrObj (EFI_IFR_VARSTORE_NAME_VALUE_OP, (CHAR8 **)&mVarStoreNameValue),
- CIfrOpHeader (EFI_IFR_VARSTORE_NAME_VALUE_OP, &mVarStoreNameValue->Header) {
+ 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) {
- memcpy (&mVarStoreNameValue->Guid, Guid, sizeof (EFI_GUID));
+ memmove (&mVarStoreNameValue->Guid, Guid, sizeof (EFI_GUID));
}
VOID SetVarStoreId (IN UINT16 VarStoreId) {
@@ -639,8 +934,8 @@ private:
EFI_IFR_IMAGE *mImage;
public:
- CIfrImage () : CIfrObj (EFI_IFR_IMAGE_OP, (CHAR8 **)&mImage),
- CIfrOpHeader (EFI_IFR_FORM_OP, &mImage->Header) {
+ CIfrImage () : CIfrObj (EFI_IFR_IMAGE_OP),
+ CIfrOpHeader (EFI_IFR_IMAGE_OP, &(GetObjBinAddr())->Header), mImage(GetObjBinAddr()) {
mImage->Id = EFI_IMAGE_ID_INVALID;
}
@@ -649,13 +944,18 @@ public:
}
};
-class CIfrLocked : public CIfrObj, public CIfrOpHeader {
-private:
- EFI_IFR_LOCKED *mLocked;
+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, (CHAR8 **)&mLocked),
- CIfrOpHeader (EFI_IFR_LOCKED_OP, &mLocked->Header) {}
+ CIfrLocked () : CIfrObj (EFI_IFR_LOCKED_OP),
+ CIfrOpHeader (EFI_IFR_LOCKED_OP, &(GetObjBinAddr())->Header) {}
};
class CIfrRule : public CIfrObj, public CIfrOpHeader {
@@ -663,9 +963,8 @@ private:
EFI_IFR_RULE *mRule;
public:
- CIfrRule () : CIfrObj (EFI_IFR_RULE_OP, (CHAR8 **)&mRule),
- mRule ((EFI_IFR_RULE *)GetObjBinAddr()),
- CIfrOpHeader (EFI_IFR_RULE_OP, &mRule->Header) {
+ CIfrRule () : CIfrObj (EFI_IFR_RULE_OP),
+ CIfrOpHeader (EFI_IFR_RULE_OP, &(GetObjBinAddr())->Header), mRule(GetObjBinAddr()) {
mRule->RuleId = EFI_RULE_ID_INVALID;
}
@@ -682,14 +981,15 @@ private:
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 **)&mDefault),
- CIfrOpHeader (EFI_IFR_DEFAULT_OP, &mDefault->Header) {
+ ) : CIfrObj (EFI_IFR_DEFAULT_OP, (CHAR8 **)NULL, Size),
+ CIfrOpHeader (EFI_IFR_DEFAULT_OP, &(GetObjBinAddr())->Header, Size), mDefault(GetObjBinAddr()) {
mDefault->Type = Type;
- mDefault->Value = Value;
mDefault->DefaultId = DefaultId;
+ memmove (&(mDefault->Value), &Value, Size - OFFSET_OF (EFI_IFR_DEFAULT, Value));
}
VOID SetDefaultId (IN UINT16 DefaultId) {
@@ -701,18 +1001,92 @@ public:
}
VOID SetValue (IN EFI_IFR_TYPE_VALUE Value) {
- mDefault->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_VALUE *mValue;
+ EFI_IFR_GET *mGet;
public:
- CIfrValue () : CIfrObj (EFI_IFR_VALUE_OP, (CHAR8 **)&mValue),
- CIfrOpHeader (EFI_IFR_VALUE_OP, &mValue->Header) {}
+ 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 {
@@ -720,9 +1094,9 @@ private:
EFI_IFR_SUBTITLE *mSubtitle;
public:
- CIfrSubtitle () : CIfrObj (EFI_IFR_SUBTITLE_OP, (CHAR8 **)&mSubtitle),
- CIfrOpHeader (EFI_IFR_SUBTITLE_OP, &mSubtitle->Header),
- CIfrStatementHeader (&mSubtitle->Statement) {
+ CIfrSubtitle () : CIfrObj (EFI_IFR_SUBTITLE_OP),
+ CIfrOpHeader (EFI_IFR_SUBTITLE_OP, &(GetObjBinAddr())->Header),
+ CIfrStatementHeader (&(GetObjBinAddr())->Statement), mSubtitle(GetObjBinAddr()) {
mSubtitle->Flags = 0;
}
@@ -740,9 +1114,9 @@ private:
EFI_IFR_TEXT *mText;
public:
- CIfrText () : CIfrObj (EFI_IFR_TEXT_OP, (CHAR8 **)&mText),
- CIfrOpHeader (EFI_IFR_TEXT_OP, &mText->Header),
- CIfrStatementHeader (&mText->Statement) {
+ CIfrText () : CIfrObj (EFI_IFR_TEXT_OP),
+ CIfrOpHeader (EFI_IFR_TEXT_OP, &(GetObjBinAddr())->Header),
+ CIfrStatementHeader (&(GetObjBinAddr())->Statement), mText(GetObjBinAddr()) {
mText->TextTwo = EFI_STRING_ID_INVALID;
}
@@ -756,9 +1130,9 @@ private:
EFI_IFR_REF *mRef;
public:
- CIfrRef () : CIfrObj (EFI_IFR_REF_OP, (CHAR8 **)&mRef),
- CIfrOpHeader (EFI_IFR_REF_OP, &mRef->Header),
- CIfrQuestionHeader (&mRef->Question) {
+ CIfrRef () : CIfrObj (EFI_IFR_REF_OP),
+ CIfrOpHeader (EFI_IFR_REF_OP, &(GetObjBinAddr())->Header),
+ CIfrQuestionHeader (&(GetObjBinAddr())->Question), mRef(GetObjBinAddr()) {
mRef->FormId = 0;
}
@@ -772,9 +1146,9 @@ private:
EFI_IFR_REF2 *mRef2;
public:
- CIfrRef2 () : CIfrObj (EFI_IFR_REF_OP, (CHAR8 **)&mRef2, sizeof (EFI_IFR_REF2)),
- CIfrOpHeader (EFI_IFR_REF_OP, &mRef2->Header, sizeof (EFI_IFR_REF2)),
- CIfrQuestionHeader (&mRef2->Question) {
+ 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;
}
@@ -783,12 +1157,8 @@ public:
mRef2->FormId = FormId;
}
- EFI_VFR_RETURN_CODE SetQuestionId (IN EFI_QUESTION_ID QuestionId) {
- if (QuestionId == EFI_QUESTION_ID_INVALID) {
- return VFR_RETURN_UNDEFINED;
- }
+ VOID SetQuestionId (IN EFI_QUESTION_ID QuestionId) {
mRef2->QuestionId = QuestionId;
- return VFR_RETURN_SUCCESS;
}
};
@@ -797,9 +1167,9 @@ private:
EFI_IFR_REF3 *mRef3;
public:
- CIfrRef3 () : CIfrObj (EFI_IFR_REF_OP, (CHAR8 **)&mRef3, sizeof(EFI_IFR_REF3)),
- CIfrOpHeader (EFI_IFR_REF_OP, &mRef3->Header, sizeof (EFI_IFR_REF3)),
- CIfrQuestionHeader (&mRef3->Question) {
+ 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));
@@ -823,9 +1193,9 @@ private:
EFI_IFR_REF4 *mRef4;
public:
- CIfrRef4 () : CIfrObj (EFI_IFR_REF_OP, (CHAR8 **)&mRef4, sizeof(EFI_IFR_REF3)),
- CIfrOpHeader (EFI_IFR_REF_OP, &mRef4->Header, sizeof (EFI_IFR_REF3)),
- CIfrQuestionHeader (&mRef4->Question) {
+ 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));
@@ -849,14 +1219,22 @@ public:
}
};
+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, (CHAR8 **)&mResetButton),
- CIfrOpHeader (EFI_IFR_RESET_BUTTON_OP, &mResetButton->Header),
- CIfrStatementHeader (&mResetButton->Question.Header) {
+ 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;
}
@@ -870,15 +1248,15 @@ private:
EFI_IFR_CHECKBOX *mCheckBox;
public:
- CIfrCheckBox () : CIfrObj (EFI_IFR_CHECKBOX_OP, (CHAR8 **)&mCheckBox),
- CIfrOpHeader (EFI_IFR_CHECKBOX_OP, &mCheckBox->Header),
- CIfrQuestionHeader (&mCheckBox->Question) {
+ CIfrCheckBox () : CIfrObj (EFI_IFR_CHECKBOX_OP),
+ CIfrOpHeader (EFI_IFR_CHECKBOX_OP, &(GetObjBinAddr())->Header),
+ CIfrQuestionHeader (&(GetObjBinAddr())->Question), mCheckBox(GetObjBinAddr()) {
mCheckBox->Flags = 0;
- gCurrentQuestion = this;
+ gCurrentQuestion = this;
}
~CIfrCheckBox () {
- gCurrentQuestion = NULL;
+ gCurrentQuestion = NULL;
}
EFI_VFR_RETURN_CODE SetFlags (IN UINT8 HFlags, UINT8 LFlags) {
@@ -910,9 +1288,9 @@ private:
EFI_IFR_ACTION *mAction;
public:
- CIfrAction () : CIfrObj (EFI_IFR_ACTION_OP, (CHAR8 **)&mAction),
- CIfrOpHeader (EFI_IFR_ACTION_OP, &mAction->Header),
- CIfrQuestionHeader (&mAction->Question) {
+ CIfrAction () : CIfrObj (EFI_IFR_ACTION_OP),
+ CIfrOpHeader (EFI_IFR_ACTION_OP, &(GetObjBinAddr())->Header),
+ CIfrQuestionHeader (&(GetObjBinAddr())->Question), mAction(GetObjBinAddr()) {
mAction->QuestionConfig = EFI_STRING_ID_INVALID;
}
@@ -926,9 +1304,9 @@ private:
EFI_IFR_DATE *mDate;
public:
- CIfrDate () : CIfrObj (EFI_IFR_DATE_OP, (CHAR8 **)&mDate),
- CIfrOpHeader (EFI_IFR_DATE_OP, &mDate->Header),
- CIfrQuestionHeader (&mDate->Question) {
+ CIfrDate () : CIfrObj (EFI_IFR_DATE_OP),
+ CIfrOpHeader (EFI_IFR_DATE_OP, &(GetObjBinAddr())->Header),
+ CIfrQuestionHeader (&(GetObjBinAddr())->Question), mDate(GetObjBinAddr()) {
mDate->Flags = 0;
}
@@ -969,19 +1347,42 @@ private:
EFI_IFR_NUMERIC *mNumeric;
public:
- CIfrNumeric () : CIfrObj (EFI_IFR_NUMERIC_OP, (CHAR8 **)&mNumeric),
- CIfrOpHeader (EFI_IFR_NUMERIC_OP, &mNumeric->Header),
- CIfrQuestionHeader (&mNumeric->Question),
- CIfrMinMaxStepData (&mNumeric->data) {
+ 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;
+ gCurrentQuestion = this;
+ gCurrentMinMaxData = this;
}
~CIfrNumeric () {
- gCurrentQuestion = NULL;
+ gCurrentQuestion = NULL;
+ gCurrentMinMaxData = NULL;
}
- EFI_VFR_RETURN_CODE SetFlags (IN UINT8 HFlags, IN UINT8 LFlags) {
+ 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);
@@ -989,13 +1390,33 @@ public:
return Ret;
}
- if (LFlags & EFI_IFR_DISPLAY) {
+ 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 | EFI_IFR_DISPLAY_UINT_DEC;
+ mNumeric->Flags = LFlags;
}
return VFR_RETURN_SUCCESS;
}
+
+ UINT8 GetNumericFlags () {
+ return mNumeric->Flags;
+ }
};
class CIfrOneOf : public CIfrObj, public CIfrOpHeader, public CIfrQuestionHeader, public CIfrMinMaxStepData {
@@ -1003,16 +1424,18 @@ private:
EFI_IFR_ONE_OF *mOneOf;
public:
- CIfrOneOf () : CIfrObj (EFI_IFR_ONE_OF_OP, (CHAR8 **)&mOneOf),
- CIfrOpHeader (EFI_IFR_ONE_OF_OP, &mOneOf->Header),
- CIfrQuestionHeader (&mOneOf->Question),
- CIfrMinMaxStepData (&mOneOf->data) {
+ 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;
+ gCurrentQuestion = this;
+ gCurrentMinMaxData = this;
}
~CIfrOneOf () {
- gCurrentQuestion = NULL;
+ gCurrentQuestion = NULL;
+ gCurrentMinMaxData = NULL;
}
EFI_VFR_RETURN_CODE SetFlags (IN UINT8 HFlags, IN UINT8 LFlags) {
@@ -1030,6 +1453,43 @@ public:
}
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 {
@@ -1037,9 +1497,9 @@ private:
EFI_IFR_STRING *mString;
public:
- CIfrString () : CIfrObj (EFI_IFR_STRING_OP, (CHAR8 **)&mString),
- CIfrOpHeader (EFI_IFR_STRING_OP, &mString->Header),
- CIfrQuestionHeader (&mString->Question) {
+ 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;
@@ -1079,9 +1539,9 @@ private:
EFI_IFR_PASSWORD *mPassword;
public:
- CIfrPassword () : CIfrObj (EFI_IFR_PASSWORD_OP, (CHAR8 **)&mPassword),
- CIfrOpHeader (EFI_IFR_PASSWORD_OP, &mPassword->Header),
- CIfrQuestionHeader (&mPassword->Question) {
+ 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;
@@ -1105,9 +1565,9 @@ private:
EFI_IFR_ORDERED_LIST *mOrderedList;
public:
- CIfrOrderedList () : CIfrObj (EFI_IFR_ORDERED_LIST_OP, (CHAR8 **)&mOrderedList),
- CIfrOpHeader (EFI_IFR_ORDERED_LIST_OP, &mOrderedList->Header),
- CIfrQuestionHeader (&mOrderedList->Question) {
+ 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;
@@ -1146,9 +1606,9 @@ private:
EFI_IFR_TIME *mTime;
public:
- CIfrTime () : CIfrObj (EFI_IFR_TIME_OP, (CHAR8 **)&mTime),
- CIfrOpHeader (EFI_IFR_TIME_OP, &mTime->Header),
- CIfrQuestionHeader (&mTime->Question) {
+ CIfrTime () : CIfrObj (EFI_IFR_TIME_OP),
+ CIfrOpHeader (EFI_IFR_TIME_OP, &(GetObjBinAddr())->Header),
+ CIfrQuestionHeader (&(GetObjBinAddr())->Question), mTime(GetObjBinAddr()) {
mTime->Flags = 0;
}
@@ -1185,31 +1645,21 @@ public:
};
class CIfrDisableIf : public CIfrObj, public CIfrOpHeader {
-private:
- EFI_IFR_DISABLE_IF *mDisableIf;
-
public:
- CIfrDisableIf () : CIfrObj (EFI_IFR_DISABLE_IF_OP, (CHAR8 **)&mDisableIf),
- mDisableIf ((EFI_IFR_DISABLE_IF *) GetObjBinAddr()),
- CIfrOpHeader (EFI_IFR_DISABLE_IF_OP, &mDisableIf->Header) {}
+ CIfrDisableIf () : CIfrObj (EFI_IFR_DISABLE_IF_OP),
+ CIfrOpHeader (EFI_IFR_DISABLE_IF_OP, &(GetObjBinAddr())->Header) {}
};
class CIfrSuppressIf : public CIfrObj, public CIfrOpHeader {
-private:
- EFI_IFR_SUPPRESS_IF *mSuppressIf;
-
public:
- CIfrSuppressIf () : CIfrObj (EFI_IFR_SUPPRESS_IF_OP, (CHAR8 **)&mSuppressIf),
- CIfrOpHeader (EFI_IFR_SUPPRESS_IF_OP, &mSuppressIf->Header) {}
+ CIfrSuppressIf () : CIfrObj (EFI_IFR_SUPPRESS_IF_OP),
+ CIfrOpHeader (EFI_IFR_SUPPRESS_IF_OP, &(GetObjBinAddr())->Header) {}
};
class CIfrGrayOutIf : public CIfrObj, public CIfrOpHeader {
-private:
- EFI_IFR_GRAY_OUT_IF *mGrayOutIf;
-
public:
- CIfrGrayOutIf () : CIfrObj (EFI_IFR_GRAY_OUT_IF_OP, (CHAR8 **)&mGrayOutIf),
- CIfrOpHeader (EFI_IFR_GRAY_OUT_IF_OP, &mGrayOutIf->Header) {}
+ CIfrGrayOutIf () : CIfrObj (EFI_IFR_GRAY_OUT_IF_OP),
+ CIfrOpHeader (EFI_IFR_GRAY_OUT_IF_OP, &(GetObjBinAddr())->Header) {}
};
class CIfrInconsistentIf : public CIfrObj, public CIfrOpHeader {
@@ -1217,8 +1667,8 @@ private:
EFI_IFR_INCONSISTENT_IF *mInconsistentIf;
public:
- CIfrInconsistentIf () : CIfrObj (EFI_IFR_INCONSISTENT_IF_OP, (CHAR8 **)&mInconsistentIf),
- CIfrOpHeader (EFI_IFR_INCONSISTENT_IF_OP, &mInconsistentIf->Header) {
+ CIfrInconsistentIf () : CIfrObj (EFI_IFR_INCONSISTENT_IF_OP),
+ CIfrOpHeader (EFI_IFR_INCONSISTENT_IF_OP, &(GetObjBinAddr())->Header), mInconsistentIf(GetObjBinAddr()) {
mInconsistentIf->Error = EFI_STRING_ID_INVALID;
}
@@ -1227,13 +1677,33 @@ public:
}
};
+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, (CHAR8 **)&mNoSubmitIf),
- CIfrOpHeader (EFI_IFR_NO_SUBMIT_IF_OP, &mNoSubmitIf->Header) {
+ 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;
}
@@ -1247,8 +1717,8 @@ private:
EFI_IFR_REFRESH *mRefresh;
public:
- CIfrRefresh () : CIfrObj (EFI_IFR_REFRESH_OP, (CHAR8 **)&mRefresh),
- CIfrOpHeader (EFI_IFR_REFRESH_OP, &mRefresh->Header) {
+ CIfrRefresh () : CIfrObj (EFI_IFR_REFRESH_OP),
+ CIfrOpHeader (EFI_IFR_REFRESH_OP, &(GetObjBinAddr())->Header), mRefresh(GetObjBinAddr()) {
mRefresh->RefreshInterval = 0;
}
@@ -1257,13 +1727,28 @@ public:
}
};
+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, (CHAR8 **)&mVarStoreDevice),
- CIfrOpHeader (EFI_IFR_VARSTORE_DEVICE_OP, &mVarStoreDevice->Header) {
+ CIfrVarStoreDevice () : CIfrObj (EFI_IFR_VARSTORE_DEVICE_OP),
+ CIfrOpHeader (EFI_IFR_VARSTORE_DEVICE_OP, &(GetObjBinAddr())->Header), mVarStoreDevice(GetObjBinAddr()) {
mVarStoreDevice->DevicePath = EFI_STRING_ID_INVALID;
}
@@ -1277,12 +1762,12 @@ private:
EFI_IFR_ONE_OF_OPTION *mOneOfOption;
public:
- CIfrOneOfOption () : CIfrObj (EFI_IFR_ONE_OF_OPTION_OP, (CHAR8 **)&mOneOfOption),
- CIfrOpHeader (EFI_IFR_ONE_OF_OPTION_OP, &mOneOfOption->Header) {
+ 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, sizeof (mOneOfOption->Value));
+ memset (&mOneOfOption->Value, 0, Size - OFFSET_OF (EFI_IFR_ONE_OF_OPTION, Value));
}
VOID SetOption (IN EFI_STRING_ID Option) {
@@ -1290,6 +1775,7 @@ public:
}
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;
}
@@ -1335,7 +1821,7 @@ public:
}
VOID SetValue (IN EFI_IFR_TYPE_VALUE Value) {
- mOneOfOption->Value = Value;
+ memmove (&mOneOfOption->Value, &Value, mOneOfOption->Header.Length - OFFSET_OF (EFI_IFR_ONE_OF_OPTION, Value));
}
UINT8 GetFlags (VOID) {
@@ -1351,8 +1837,8 @@ private:
EFI_IFR_GUID_CLASS *mClass;
public:
- CIfrClass () : CIfrObj (EFI_IFR_GUID_OP, (CHAR8 **)&mClass, sizeof (EFI_IFR_GUID_CLASS)),
- CIfrOpHeader (EFI_IFR_GUID_OP, &mClass->Header, sizeof (EFI_IFR_GUID_CLASS)) {
+ 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;
@@ -1368,8 +1854,8 @@ private:
EFI_IFR_GUID_SUBCLASS *mSubClass;
public:
- CIfrSubClass () : CIfrObj (EFI_IFR_GUID_OP, (CHAR8 **)&mSubClass, sizeof (EFI_IFR_GUID_SUBCLASS)),
- CIfrOpHeader (EFI_IFR_GUID_OP, &mSubClass->Header, sizeof (EFI_IFR_GUID_SUBCLASS)) {
+ 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;
@@ -1385,8 +1871,8 @@ private:
EFI_IFR_GUID_LABEL *mLabel;
public:
- CIfrLabel () : CIfrObj (EFI_IFR_GUID_OP, (CHAR8 **)&mLabel, sizeof (EFI_IFR_GUID_LABEL)),
- CIfrOpHeader (EFI_IFR_GUID_OP, &mLabel->Header, sizeof (EFI_IFR_GUID_LABEL)) {
+ 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;
}
@@ -1401,8 +1887,8 @@ private:
EFI_IFR_GUID_BANNER *mBanner;
public:
- CIfrBanner () : CIfrObj (EFI_IFR_GUID_OP, (CHAR8 **)&mBanner, sizeof (EFI_IFR_GUID_BANNER)),
- CIfrOpHeader (EFI_IFR_GUID_OP, &mBanner->Header, sizeof (EFI_IFR_GUID_BANNER)) {
+ 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;
}
@@ -1429,8 +1915,8 @@ public:
IN EFI_QUESTION_ID QuestionId,
IN EFI_IFR_TYPE_VALUE &OptionValue,
IN EFI_QUESTION_ID KeyValue
- ) : CIfrObj (EFI_IFR_GUID_OP, (CHAR8 **)&mOptionKey, sizeof (EFI_IFR_GUID_OPTIONKEY)),
- CIfrOpHeader (EFI_IFR_GUID_OP, &mOptionKey->Header, sizeof (EFI_IFR_GUID_OPTIONKEY)) {
+ ) : 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;
@@ -1447,8 +1933,8 @@ public:
CIfrVarEqName (
IN EFI_QUESTION_ID QuestionId,
IN EFI_STRING_ID NameId
- ) : CIfrObj (EFI_IFR_GUID_OP, (CHAR8 **)&mVarEqName, sizeof (EFI_IFR_GUID_VAREQNAME)),
- CIfrOpHeader (EFI_IFR_GUID_OP, &mVarEqName->Header, sizeof (EFI_IFR_GUID_VAREQNAME)) {
+ ) : 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;
@@ -1461,8 +1947,8 @@ private:
EFI_IFR_GUID_TIMEOUT *mTimeout;
public:
- CIfrTimeout (IN UINT16 Timeout = 0) : CIfrObj (EFI_IFR_GUID_OP, (CHAR8 **)&mTimeout, sizeof (EFI_IFR_GUID_TIMEOUT)),
- CIfrOpHeader (EFI_IFR_GUID_OP, &mTimeout->Header, sizeof (EFI_IFR_GUID_TIMEOUT)) {
+ 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;
@@ -1473,15 +1959,31 @@ public:
}
};
-class CIfrDup : public CIfrObj, public CIfrOpHeader {
+class CIfrGuid : public CIfrObj, public CIfrOpHeader {
private:
- EFI_IFR_DUP *mDup;
+ 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, (CHAR8 **)&mDup),
- CIfrOpHeader (EFI_IFR_DUP_OP, &mDup->Header) {
+ ) : CIfrObj (EFI_IFR_DUP_OP),
+ CIfrOpHeader (EFI_IFR_DUP_OP, &(GetObjBinAddr())->Header) {
SetLineNo (LineNo);
}
};
@@ -1493,8 +1995,8 @@ private:
public:
CIfrEqIdId (
IN UINT32 LineNo
- ) : CIfrObj (EFI_IFR_EQ_ID_ID_OP, (CHAR8 **)&mEqIdId),
- CIfrOpHeader (EFI_IFR_EQ_ID_ID_OP, &mEqIdId->Header) {
+ ) : 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;
@@ -1532,8 +2034,8 @@ private:
public:
CIfrEqIdVal (
IN UINT32 LineNo
- ) : CIfrObj (EFI_IFR_EQ_ID_VAL_OP, (CHAR8 **)&mEqIdVal),
- CIfrOpHeader (EFI_IFR_EQ_ID_VAL_OP, &mEqIdVal->Header) {
+ ) : 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;
}
@@ -1557,13 +2059,13 @@ public:
class CIfrEqIdList : public CIfrObj, public CIfrOpHeader {
private:
- EFI_IFR_EQ_ID_LIST *mEqIdVList;
+ EFI_IFR_EQ_ID_VAL_LIST *mEqIdVList;
public:
CIfrEqIdList (
IN UINT32 LineNo
- ) : CIfrObj (EFI_IFR_EQ_ID_LIST_OP, (CHAR8 **)&mEqIdVList, sizeof (EFI_IFR_EQ_ID_LIST), TRUE),
- CIfrOpHeader (EFI_IFR_EQ_ID_LIST_OP, &mEqIdVList->Header) {
+ ) : 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;
@@ -1573,7 +2075,7 @@ public:
VOID UpdateIfrBuffer (
) {
_EMIT_PENDING_OBJ();
- mEqIdVList = (EFI_IFR_EQ_ID_LIST *) GetObjBinAddr();
+ mEqIdVList = GetObjBinAddr();
UpdateHeader (&mEqIdVList->Header);
}
@@ -1613,8 +2115,8 @@ private:
public:
CIfrQuestionRef1 (
IN UINT32 LineNo
- ) : CIfrObj (EFI_IFR_QUESTION_REF1_OP, (CHAR8 **)&mQuestionRef1),
- CIfrOpHeader (EFI_IFR_QUESTION_REF1_OP, &mQuestionRef1->Header) {
+ ) : CIfrObj (EFI_IFR_QUESTION_REF1_OP),
+ CIfrOpHeader (EFI_IFR_QUESTION_REF1_OP, &(GetObjBinAddr())->Header), mQuestionRef1(GetObjBinAddr()) {
SetLineNo (LineNo);
mQuestionRef1->QuestionId = EFI_QUESTION_ID_INVALID;
}
@@ -1633,27 +2135,21 @@ public:
};
class CIfrQuestionRef2 : public CIfrObj, public CIfrOpHeader {
-private:
- EFI_IFR_QUESTION_REF2 *mQuestionRef2;
-
public:
CIfrQuestionRef2 (
IN UINT32 LineNo
- ) : CIfrObj (EFI_IFR_QUESTION_REF2_OP, (CHAR8 **)&mQuestionRef2),
- CIfrOpHeader (EFI_IFR_QUESTION_REF2_OP, &mQuestionRef2->Header) {
+ ) : CIfrObj (EFI_IFR_QUESTION_REF2_OP),
+ CIfrOpHeader (EFI_IFR_QUESTION_REF2_OP, &(GetObjBinAddr())->Header) {
SetLineNo (LineNo);
}
};
class CIfrQuestionRef3 : public CIfrObj, public CIfrOpHeader {
-private:
- EFI_IFR_QUESTION_REF3 *mQuestionRef3;
-
public:
CIfrQuestionRef3 (
IN UINT32 LineNo
- ) : CIfrObj (EFI_IFR_QUESTION_REF3_OP, (CHAR8 **)&mQuestionRef3),
- CIfrOpHeader (EFI_IFR_QUESTION_REF3_OP, &mQuestionRef3->Header) {
+ ) : CIfrObj (EFI_IFR_QUESTION_REF3_OP),
+ CIfrOpHeader (EFI_IFR_QUESTION_REF3_OP, &(GetObjBinAddr())->Header) {
SetLineNo (LineNo);
}
};
@@ -1665,8 +2161,8 @@ private:
public:
CIfrQuestionRef3_2 (
IN UINT32 LineNo
- ) : CIfrObj (EFI_IFR_QUESTION_REF3_OP, (CHAR8 **)&mQuestionRef3_2, sizeof (EFI_IFR_QUESTION_REF3_2)),
- CIfrOpHeader (EFI_IFR_QUESTION_REF3_OP, &mQuestionRef3_2->Header, sizeof (EFI_IFR_QUESTION_REF3_2)) {
+ ) : 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;
}
@@ -1683,8 +2179,8 @@ private:
public:
CIfrQuestionRef3_3 (
IN UINT32 LineNo
- ) : CIfrObj (EFI_IFR_QUESTION_REF3_OP, (CHAR8 **)&mQuestionRef3_3, sizeof (EFI_IFR_QUESTION_REF3_3)),
- CIfrOpHeader (EFI_IFR_QUESTION_REF3_OP, &mQuestionRef3_3->Header, sizeof (EFI_IFR_QUESTION_REF3_3)) {
+ ) : 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));
@@ -1706,8 +2202,8 @@ private:
public:
CIfrRuleRef (
IN UINT32 LineNo
- ) : CIfrObj (EFI_IFR_RULE_REF_OP, (CHAR8 **)&mRuleRef),
- CIfrOpHeader (EFI_IFR_RULE_REF_OP, &mRuleRef->Header) {
+ ) : CIfrObj (EFI_IFR_RULE_REF_OP),
+ CIfrOpHeader (EFI_IFR_RULE_REF_OP, &(GetObjBinAddr())->Header), mRuleRef(GetObjBinAddr()) {
SetLineNo (LineNo);
mRuleRef->RuleId = EFI_RULE_ID_INVALID;
}
@@ -1724,8 +2220,8 @@ private:
public:
CIfrStringRef1 (
IN UINT32 LineNo
- ) : CIfrObj (EFI_IFR_STRING_REF1_OP, (CHAR8 **)&mStringRef1),
- CIfrOpHeader (EFI_IFR_STRING_REF1_OP, &mStringRef1->Header) {
+ ) : CIfrObj (EFI_IFR_STRING_REF1_OP),
+ CIfrOpHeader (EFI_IFR_STRING_REF1_OP, &(GetObjBinAddr())->Header), mStringRef1(GetObjBinAddr()) {
SetLineNo (LineNo);
mStringRef1->StringId = EFI_STRING_ID_INVALID;
}
@@ -1736,28 +2232,40 @@ public:
};
class CIfrStringRef2 : public CIfrObj, public CIfrOpHeader {
-private:
- EFI_IFR_STRING_REF2 *mStringRef2;
-
public:
CIfrStringRef2 (
IN UINT32 LineNo
- ) : CIfrObj (EFI_IFR_STRING_REF2_OP, (CHAR8 **)&mStringRef2),
- CIfrOpHeader (EFI_IFR_STRING_REF2_OP, &mStringRef2->Header) {
+ ) : 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_THIS *mThis;
+ EFI_IFR_SECURITY *mSecurity;
public:
- CIfrThis (
+ CIfrSecurity (
IN UINT32 LineNo
- ) : CIfrObj (EFI_IFR_THIS_OP, (CHAR8 **)&mThis),
- CIfrOpHeader (EFI_IFR_THIS_OP, &mThis->Header) {
+ ) : 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));
}
};
@@ -1768,8 +2276,8 @@ private:
public:
CIfrUint8 (
IN UINT32 LineNo
- ) : CIfrObj (EFI_IFR_UINT8_OP, (CHAR8 **)&mUint8),
- CIfrOpHeader (EFI_IFR_UINT8_OP, &mUint8->Header) {
+ ) : CIfrObj (EFI_IFR_UINT8_OP),
+ CIfrOpHeader (EFI_IFR_UINT8_OP, &(GetObjBinAddr())->Header), mUint8(GetObjBinAddr()) {
SetLineNo (LineNo);
}
@@ -1785,8 +2293,8 @@ private:
public:
CIfrUint16 (
IN UINT32 LineNo
- ) : CIfrObj (EFI_IFR_UINT16_OP, (CHAR8 **)&mUint16),
- CIfrOpHeader (EFI_IFR_UINT16_OP, &mUint16->Header) {
+ ) : CIfrObj (EFI_IFR_UINT16_OP),
+ CIfrOpHeader (EFI_IFR_UINT16_OP, &(GetObjBinAddr())->Header), mUint16(GetObjBinAddr()) {
SetLineNo (LineNo);
}
@@ -1802,8 +2310,8 @@ private:
public:
CIfrUint32 (
IN UINT32 LineNo
- ) : CIfrObj (EFI_IFR_UINT32_OP, (CHAR8 **)&mUint32),
- CIfrOpHeader (EFI_IFR_UINT32_OP, &mUint32->Header) {
+ ) : CIfrObj (EFI_IFR_UINT32_OP),
+ CIfrOpHeader (EFI_IFR_UINT32_OP, &(GetObjBinAddr())->Header), mUint32(GetObjBinAddr()) {
SetLineNo (LineNo);
}
@@ -1819,8 +2327,8 @@ private:
public:
CIfrUint64 (
IN UINT32 LineNo
- ) : CIfrObj (EFI_IFR_UINT64_OP, (CHAR8 **)&mUint64),
- CIfrOpHeader (EFI_IFR_UINT64_OP, &mUint64->Header) {
+ ) : CIfrObj (EFI_IFR_UINT64_OP),
+ CIfrOpHeader (EFI_IFR_UINT64_OP, &(GetObjBinAddr())->Header), mUint64(GetObjBinAddr()) {
SetLineNo (LineNo);
}
@@ -1830,144 +2338,111 @@ public:
};
class CIfrTrue : public CIfrObj, public CIfrOpHeader {
-private:
- EFI_IFR_TRUE *mTrue;
-
public:
CIfrTrue (
IN UINT32 LineNo
- ) : CIfrObj (EFI_IFR_TRUE_OP, (CHAR8 **)&mTrue),
- CIfrOpHeader (EFI_IFR_TRUE_OP, &mTrue->Header) {
+ ) : CIfrObj (EFI_IFR_TRUE_OP),
+ CIfrOpHeader (EFI_IFR_TRUE_OP, &(GetObjBinAddr())->Header) {
SetLineNo (LineNo);
}
};
class CIfrFalse : public CIfrObj, public CIfrOpHeader {
-private:
- EFI_IFR_FALSE *mFalse;
-
public:
CIfrFalse (
IN UINT32 LineNo
- ) : CIfrObj (EFI_IFR_FALSE_OP, (CHAR8 **)&mFalse),
- CIfrOpHeader (EFI_IFR_FALSE_OP, &mFalse->Header) {
+ ) : CIfrObj (EFI_IFR_FALSE_OP),
+ CIfrOpHeader (EFI_IFR_FALSE_OP, &(GetObjBinAddr())->Header) {
SetLineNo (LineNo);
}
};
class CIfrOne : public CIfrObj, public CIfrOpHeader {
-private:
- EFI_IFR_ONE *mOne;
-
public:
CIfrOne (
IN UINT32 LineNo
- ) : CIfrObj (EFI_IFR_ONE_OP, (CHAR8 **)&mOne),
- CIfrOpHeader (EFI_IFR_ONE_OP, &mOne->Header) {
+ ) : CIfrObj (EFI_IFR_ONE_OP),
+ CIfrOpHeader (EFI_IFR_ONE_OP, &(GetObjBinAddr())->Header) {
SetLineNo (LineNo);
}
};
class CIfrOnes : public CIfrObj, public CIfrOpHeader {
-private:
- EFI_IFR_ONES *mOnes;
-
public:
CIfrOnes (
IN UINT32 LineNo
- ) : CIfrObj (EFI_IFR_ONES_OP, (CHAR8 **)&mOnes),
- CIfrOpHeader (EFI_IFR_ONES_OP, &mOnes->Header) {
+ ) : CIfrObj (EFI_IFR_ONES_OP),
+ CIfrOpHeader (EFI_IFR_ONES_OP, &(GetObjBinAddr())->Header) {
SetLineNo (LineNo);
}
};
class CIfrZero : public CIfrObj, public CIfrOpHeader {
-private:
- EFI_IFR_ZERO *mZero;
-
public:
CIfrZero (
IN UINT32 LineNo
- ) : CIfrObj (EFI_IFR_ZERO_OP, (CHAR8 **)&mZero),
- CIfrOpHeader (EFI_IFR_ZERO_OP, &mZero->Header) {
+ ) : CIfrObj (EFI_IFR_ZERO_OP),
+ CIfrOpHeader (EFI_IFR_ZERO_OP, &(GetObjBinAddr())->Header) {
SetLineNo (LineNo);
}
};
class CIfrUndefined : public CIfrObj, public CIfrOpHeader {
-private:
- EFI_IFR_UNDEFINED *mUndefined;
-
public:
CIfrUndefined (
IN UINT32 LineNo
- ) : CIfrObj (EFI_IFR_UNDEFINED_OP, (CHAR8 **)&mUndefined),
- CIfrOpHeader (EFI_IFR_UNDEFINED_OP, &mUndefined->Header) {
+ ) : CIfrObj (EFI_IFR_UNDEFINED_OP),
+ CIfrOpHeader (EFI_IFR_UNDEFINED_OP, &(GetObjBinAddr())->Header) {
SetLineNo (LineNo);
}
};
class CIfrVersion : public CIfrObj, public CIfrOpHeader {
-private:
- EFI_IFR_VERSION *mVersion;
-
public:
CIfrVersion (
IN UINT32 LineNo
- ) : CIfrObj (EFI_IFR_VERSION_OP, (CHAR8 **)&mVersion),
- CIfrOpHeader (EFI_IFR_VERSION_OP, &mVersion->Header) {
+ ) : CIfrObj (EFI_IFR_VERSION_OP),
+ CIfrOpHeader (EFI_IFR_VERSION_OP, &(GetObjBinAddr())->Header) {
SetLineNo (LineNo);
}
};
class CIfrLength : public CIfrObj, public CIfrOpHeader {
-private:
- EFI_IFR_LENGTH *mLength;
-
public:
CIfrLength (
IN UINT32 LineNo
- ) : CIfrObj (EFI_IFR_LENGTH_OP, (CHAR8 **)&mLength),
- CIfrOpHeader (EFI_IFR_LENGTH_OP, &mLength->Header) {
+ ) : CIfrObj (EFI_IFR_LENGTH_OP),
+ CIfrOpHeader (EFI_IFR_LENGTH_OP, &(GetObjBinAddr())->Header) {
SetLineNo (LineNo);
}
};
class CIfrNot : public CIfrObj, public CIfrOpHeader {
-private:
- EFI_IFR_NOT *mNot;
-
public:
CIfrNot (
IN UINT32 LineNo
- ) : CIfrObj (EFI_IFR_NOT_OP, (CHAR8 **)&mNot),
- CIfrOpHeader (EFI_IFR_NOT_OP, &mNot->Header) {
+ ) : CIfrObj (EFI_IFR_NOT_OP),
+ CIfrOpHeader (EFI_IFR_NOT_OP, &(GetObjBinAddr())->Header) {
SetLineNo (LineNo);
}
};
class CIfrBitWiseNot : public CIfrObj, public CIfrOpHeader {
-private:
- EFI_IFR_BITWISE_NOT *mBitWise;
-
public:
CIfrBitWiseNot (
IN UINT32 LineNo
- ) : CIfrObj (EFI_IFR_BITWISE_NOT_OP, (CHAR8 **)&mBitWise),
- CIfrOpHeader (EFI_IFR_BITWISE_NOT_OP, &mBitWise->Header) {
+ ) : CIfrObj (EFI_IFR_BITWISE_NOT_OP),
+ CIfrOpHeader (EFI_IFR_BITWISE_NOT_OP, &(GetObjBinAddr())->Header) {
SetLineNo (LineNo);
}
};
class CIfrToBoolean : public CIfrObj, public CIfrOpHeader {
-private:
- EFI_IFR_TO_BOOLEAN *mToBoolean;
-
public:
CIfrToBoolean (
IN UINT32 LineNo
- ) : CIfrObj (EFI_IFR_TO_BOOLEAN_OP, (CHAR8 **)&mToBoolean),
- CIfrOpHeader (EFI_IFR_TO_BOOLEAN_OP, &mToBoolean->Header) {
+ ) : CIfrObj (EFI_IFR_TO_BOOLEAN_OP),
+ CIfrOpHeader (EFI_IFR_TO_BOOLEAN_OP, &(GetObjBinAddr())->Header) {
SetLineNo (LineNo);
}
};
@@ -1979,8 +2454,8 @@ private:
public:
CIfrToString (
IN UINT32 LineNo
- ) : CIfrObj (EFI_IFR_TO_STRING_OP, (CHAR8 **)&mToString),
- CIfrOpHeader (EFI_IFR_TO_STRING_OP, &mToString->Header) {
+ ) : CIfrObj (EFI_IFR_TO_STRING_OP),
+ CIfrOpHeader (EFI_IFR_TO_STRING_OP, &(GetObjBinAddr())->Header), mToString(GetObjBinAddr()) {
SetLineNo (LineNo);
}
@@ -1990,300 +2465,256 @@ public:
};
class CIfrToUint : public CIfrObj, public CIfrOpHeader {
-private:
- EFI_IFR_TO_UINT *mToUint;
-
public:
CIfrToUint (
IN UINT32 LineNo
- ) : CIfrObj (EFI_IFR_TO_UINT_OP, (CHAR8 **)&mToUint),
- CIfrOpHeader (EFI_IFR_TO_UINT_OP, &mToUint->Header) {
+ ) : CIfrObj (EFI_IFR_TO_UINT_OP),
+ CIfrOpHeader (EFI_IFR_TO_UINT_OP, &(GetObjBinAddr())->Header) {
SetLineNo (LineNo);
}
};
class CIfrToUpper : public CIfrObj, public CIfrOpHeader {
-private:
- EFI_IFR_TO_UPPER *mToUpper;
-
public:
CIfrToUpper (
IN UINT32 LineNo
- ) : CIfrObj (EFI_IFR_TO_UPPER_OP, (CHAR8 **)&mToUpper),
- CIfrOpHeader (EFI_IFR_TO_UPPER_OP, &mToUpper->Header) {
+ ) : CIfrObj (EFI_IFR_TO_UPPER_OP),
+ CIfrOpHeader (EFI_IFR_TO_UPPER_OP, &(GetObjBinAddr())->Header) {
SetLineNo (LineNo);
}
};
class CIfrToLower : public CIfrObj, public CIfrOpHeader {
-private:
- EFI_IFR_TO_LOWER *mToLower;
-
public:
CIfrToLower (
IN UINT32 LineNo
- ) : CIfrObj (EFI_IFR_TO_LOWER_OP, (CHAR8 **)&mToLower),
- CIfrOpHeader (EFI_IFR_TO_LOWER_OP, &mToLower->Header) {
+ ) : CIfrObj (EFI_IFR_TO_LOWER_OP),
+ CIfrOpHeader (EFI_IFR_TO_LOWER_OP, &(GetObjBinAddr())->Header) {
SetLineNo (LineNo);
}
};
class CIfrAdd : public CIfrObj, public CIfrOpHeader {
-private:
- EFI_IFR_ADD *mAdd;
-
public:
CIfrAdd (
IN UINT32 LineNo
- ) : CIfrObj (EFI_IFR_ADD_OP, (CHAR8 **)&mAdd),
- CIfrOpHeader (EFI_IFR_ADD_OP, &mAdd->Header) {
+ ) : CIfrObj (EFI_IFR_ADD_OP),
+ CIfrOpHeader (EFI_IFR_ADD_OP, &(GetObjBinAddr())->Header) {
SetLineNo (LineNo);
}
};
class CIfrBitWiseAnd : public CIfrObj, public CIfrOpHeader {
-private:
- EFI_IFR_BITWISE_AND *mBitWiseAnd;
-
public:
CIfrBitWiseAnd (
IN UINT32 LineNo
- ) : CIfrObj (EFI_IFR_BITWISE_AND_OP, (CHAR8 **)&mBitWiseAnd),
- CIfrOpHeader (EFI_IFR_BITWISE_AND_OP, &mBitWiseAnd->Header) {
+ ) : CIfrObj (EFI_IFR_BITWISE_AND_OP),
+ CIfrOpHeader (EFI_IFR_BITWISE_AND_OP, &(GetObjBinAddr())->Header) {
SetLineNo(LineNo);
}
};
class CIfrBitWiseOr : public CIfrObj, public CIfrOpHeader {
-private:
- EFI_IFR_BITWISE_OR *mBitWiseOr;
-
public:
CIfrBitWiseOr (
IN UINT32 LineNo
- ) : CIfrObj (EFI_IFR_BITWISE_OR_OP, (CHAR8 **)&mBitWiseOr),
- CIfrOpHeader (EFI_IFR_BITWISE_OR_OP, &mBitWiseOr->Header) {
+ ) : CIfrObj (EFI_IFR_BITWISE_OR_OP),
+ CIfrOpHeader (EFI_IFR_BITWISE_OR_OP, &(GetObjBinAddr())->Header) {
SetLineNo (LineNo);
}
};
class CIfrAnd : public CIfrObj, public CIfrOpHeader {
-private:
- EFI_IFR_AND *mAnd;
-
public:
CIfrAnd (
IN UINT32 LineNo
- ) : CIfrObj (EFI_IFR_AND_OP, (CHAR8 **)&mAnd),
- CIfrOpHeader (EFI_IFR_AND_OP, &mAnd->Header) {
+ ) : CIfrObj (EFI_IFR_AND_OP),
+ CIfrOpHeader (EFI_IFR_AND_OP, &(GetObjBinAddr())->Header) {
SetLineNo (LineNo);
}
};
class CIfrCatenate : public CIfrObj, public CIfrOpHeader {
-private:
- EFI_IFR_CATENATE *mCatenate;
-
public:
CIfrCatenate (
IN UINT32 LineNo
- ) : CIfrObj (EFI_IFR_CATENATE_OP, (CHAR8 **)&mCatenate),
- CIfrOpHeader (EFI_IFR_CATENATE_OP, &mCatenate->Header) {
+ ) : CIfrObj (EFI_IFR_CATENATE_OP),
+ CIfrOpHeader (EFI_IFR_CATENATE_OP, &(GetObjBinAddr())->Header) {
SetLineNo (LineNo);
}
};
class CIfrDivide : public CIfrObj, public CIfrOpHeader {
-private:
- EFI_IFR_DIVIDE *mDivide;
-
public:
CIfrDivide (
IN UINT32 LineNo
- ) : CIfrObj (EFI_IFR_DIVIDE_OP, (CHAR8 **)&mDivide),
- CIfrOpHeader (EFI_IFR_DIVIDE_OP, &mDivide->Header) {
+ ) : CIfrObj (EFI_IFR_DIVIDE_OP),
+ CIfrOpHeader (EFI_IFR_DIVIDE_OP, &(GetObjBinAddr())->Header) {
SetLineNo (LineNo);
}
};
class CIfrEqual : public CIfrObj, public CIfrOpHeader {
-private:
- EFI_IFR_EQUAL *mEqual;
-
public:
CIfrEqual (
IN UINT32 LineNo
- ) : CIfrObj (EFI_IFR_EQUAL_OP, (CHAR8 **)&mEqual),
- CIfrOpHeader (EFI_IFR_EQUAL_OP, &mEqual->Header) {
+ ) : CIfrObj (EFI_IFR_EQUAL_OP),
+ CIfrOpHeader (EFI_IFR_EQUAL_OP, &(GetObjBinAddr())->Header) {
SetLineNo (LineNo);
}
};
class CIfrGreaterEqual : public CIfrObj, public CIfrOpHeader {
-private:
- EFI_IFR_GREATER_EQUAL *mGreaterEqual;
-
public:
CIfrGreaterEqual (
IN UINT32 LineNo
- ) : CIfrObj (EFI_IFR_GREATER_EQUAL_OP, (CHAR8 **)&mGreaterEqual),
- CIfrOpHeader (EFI_IFR_GREATER_EQUAL_OP, &mGreaterEqual->Header) {
+ ) : CIfrObj (EFI_IFR_GREATER_EQUAL_OP),
+ CIfrOpHeader (EFI_IFR_GREATER_EQUAL_OP, &(GetObjBinAddr())->Header) {
SetLineNo (LineNo);
}
};
class CIfrGreaterThan : public CIfrObj, public CIfrOpHeader {
-private:
- EFI_IFR_GREATER_THAN *mGreaterThan;
-
public:
CIfrGreaterThan (
IN UINT32 LineNo
- ) : CIfrObj (EFI_IFR_GREATER_THAN_OP, (CHAR8 **)&mGreaterThan),
- CIfrOpHeader (EFI_IFR_GREATER_THAN_OP, &mGreaterThan->Header) {
+ ) : CIfrObj (EFI_IFR_GREATER_THAN_OP),
+ CIfrOpHeader (EFI_IFR_GREATER_THAN_OP, &(GetObjBinAddr())->Header) {
SetLineNo (LineNo);
}
};
class CIfrLessEqual : public CIfrObj, public CIfrOpHeader {
-private:
- EFI_IFR_LESS_EQUAL *mLessEqual;
-
public:
CIfrLessEqual (
IN UINT32 LineNo
- ) : CIfrObj (EFI_IFR_LESS_EQUAL_OP, (CHAR8 **)&mLessEqual),
- CIfrOpHeader (EFI_IFR_LESS_EQUAL_OP, &mLessEqual->Header) {
+ ) : CIfrObj (EFI_IFR_LESS_EQUAL_OP),
+ CIfrOpHeader (EFI_IFR_LESS_EQUAL_OP, &(GetObjBinAddr())->Header) {
SetLineNo (LineNo);
}
};
class CIfrLessThan : public CIfrObj, public CIfrOpHeader {
-private:
- EFI_IFR_LESS_THAN *mLessThan;
-
public:
CIfrLessThan (
IN UINT32 LineNo
- ) : CIfrObj (EFI_IFR_LESS_THAN_OP, (CHAR8 **)&mLessThan),
- CIfrOpHeader (EFI_IFR_LESS_THAN_OP, &mLessThan->Header) {
+ ) : CIfrObj (EFI_IFR_LESS_THAN_OP),
+ CIfrOpHeader (EFI_IFR_LESS_THAN_OP, &(GetObjBinAddr())->Header) {
SetLineNo (LineNo);
}
};
-class CIfrMatch : public CIfrObj, public CIfrOpHeader {
-private:
- EFI_IFR_MATCH *mMatch;
+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, (CHAR8 **)&mMatch),
- CIfrOpHeader (EFI_IFR_MATCH_OP, &mMatch->Header) {
+ ) : CIfrObj (EFI_IFR_MATCH_OP),
+ CIfrOpHeader (EFI_IFR_MATCH_OP, &(GetObjBinAddr())->Header) {
SetLineNo (LineNo);
}
};
-class CIfrMultiply : public CIfrObj, public CIfrOpHeader {
+class CIfrMatch2 : public CIfrObj, public CIfrOpHeader {
private:
- EFI_IFR_MULTIPLY *mMultiply;
+ 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, (CHAR8 **)&mMultiply),
- CIfrOpHeader (EFI_IFR_MULTIPLY_OP, &mMultiply->Header) {
+ ) : CIfrObj (EFI_IFR_MULTIPLY_OP),
+ CIfrOpHeader (EFI_IFR_MULTIPLY_OP, &(GetObjBinAddr())->Header) {
SetLineNo (LineNo);
}
};
class CIfrModulo : public CIfrObj, public CIfrOpHeader {
-private:
- EFI_IFR_MODULO *mModulo;
-
public:
CIfrModulo (
IN UINT32 LineNo
- ) : CIfrObj (EFI_IFR_MODULO_OP, (CHAR8 **)&mModulo),
- CIfrOpHeader (EFI_IFR_MODULO_OP, &mModulo->Header) {
+ ) : CIfrObj (EFI_IFR_MODULO_OP),
+ CIfrOpHeader (EFI_IFR_MODULO_OP, &(GetObjBinAddr())->Header) {
SetLineNo (LineNo);
}
};
class CIfrNotEqual : public CIfrObj, public CIfrOpHeader {
-private:
- EFI_IFR_NOT_EQUAL *mNotEqual;
-
public:
CIfrNotEqual (
IN UINT32 LineNo
- ) : CIfrObj (EFI_IFR_NOT_EQUAL_OP, (CHAR8 **)&mNotEqual),
- CIfrOpHeader (EFI_IFR_NOT_EQUAL_OP, &mNotEqual->Header) {
+ ) : CIfrObj (EFI_IFR_NOT_EQUAL_OP),
+ CIfrOpHeader (EFI_IFR_NOT_EQUAL_OP, &(GetObjBinAddr())->Header) {
SetLineNo (LineNo);
}
};
class CIfrOr : public CIfrObj, public CIfrOpHeader {
-private:
- EFI_IFR_OR *mOr;
-
public:
CIfrOr (
IN UINT32 LineNo
- ) : CIfrObj (EFI_IFR_OR_OP, (CHAR8 **)&mOr),
- CIfrOpHeader (EFI_IFR_OR_OP, &mOr->Header) {
+ ) : CIfrObj (EFI_IFR_OR_OP),
+ CIfrOpHeader (EFI_IFR_OR_OP, &(GetObjBinAddr())->Header) {
SetLineNo (LineNo);
}
};
class CIfrShiftLeft : public CIfrObj, public CIfrOpHeader {
-private:
- EFI_IFR_SHIFT_LEFT *mShiftLeft;
-
public:
CIfrShiftLeft (
IN UINT32 LineNo
- ) : CIfrObj (EFI_IFR_SHIFT_LEFT_OP, (CHAR8 **)&mShiftLeft),
- CIfrOpHeader (EFI_IFR_SHIFT_LEFT_OP, &mShiftLeft->Header) {
+ ) : CIfrObj (EFI_IFR_SHIFT_LEFT_OP),
+ CIfrOpHeader (EFI_IFR_SHIFT_LEFT_OP, &(GetObjBinAddr())->Header) {
SetLineNo (LineNo);
}
};
class CIfrShiftRight : public CIfrObj, public CIfrOpHeader {
-private:
- EFI_IFR_SHIFT_RIGHT *mShiftRight;
-
public:
CIfrShiftRight (
IN UINT32 LineNo
- ) : CIfrObj (EFI_IFR_SHIFT_RIGHT_OP, (CHAR8 **)&mShiftRight),
- CIfrOpHeader (EFI_IFR_SHIFT_RIGHT_OP, &mShiftRight->Header) {
+ ) : CIfrObj (EFI_IFR_SHIFT_RIGHT_OP),
+ CIfrOpHeader (EFI_IFR_SHIFT_RIGHT_OP, &(GetObjBinAddr())->Header) {
SetLineNo (LineNo);
}
};
class CIfrSubtract : public CIfrObj, public CIfrOpHeader {
-private:
- EFI_IFR_SUBTRACT *mSubtract;
-
public:
CIfrSubtract (
IN UINT32 LineNo
- ) : CIfrObj (EFI_IFR_SUBTRACT_OP, (CHAR8 **)&mSubtract),
- CIfrOpHeader (EFI_IFR_SUBTRACT_OP, &mSubtract->Header) {
+ ) : CIfrObj (EFI_IFR_SUBTRACT_OP),
+ CIfrOpHeader (EFI_IFR_SUBTRACT_OP, &(GetObjBinAddr())->Header) {
SetLineNo (LineNo);
}
};
class CIfrConditional : public CIfrObj, public CIfrOpHeader {
-private:
- EFI_IFR_CONDITIONAL *mConditional;
-
public:
CIfrConditional (
IN UINT32 LineNo
- ) : CIfrObj (EFI_IFR_CONDITIONAL_OP, (CHAR8 **)&mConditional),
- CIfrOpHeader (EFI_IFR_CONDITIONAL_OP, &mConditional->Header) {
+ ) : CIfrObj (EFI_IFR_CONDITIONAL_OP),
+ CIfrOpHeader (EFI_IFR_CONDITIONAL_OP, &(GetObjBinAddr())->Header) {
SetLineNo (LineNo);
}
};
@@ -2295,8 +2726,8 @@ private:
public:
CIfrFind (
IN UINT32 LineNo
- ) : CIfrObj (EFI_IFR_FIND_OP, (CHAR8 **)&mFind),
- CIfrOpHeader (EFI_IFR_FIND_OP, &mFind->Header) {
+ ) : CIfrObj (EFI_IFR_FIND_OP),
+ CIfrOpHeader (EFI_IFR_FIND_OP, &(GetObjBinAddr())->Header), mFind(GetObjBinAddr()) {
SetLineNo (LineNo);
}
@@ -2306,27 +2737,21 @@ public:
};
class CIfrMid : public CIfrObj, public CIfrOpHeader {
-private:
- EFI_IFR_MID *mMid;
-
public:
CIfrMid (
IN UINT32 LineNo
- ) : CIfrObj (EFI_IFR_MID_OP, (CHAR8 **)&mMid),
- CIfrOpHeader (EFI_IFR_MID_OP, &mMid->Header) {
+ ) : CIfrObj (EFI_IFR_MID_OP),
+ CIfrOpHeader (EFI_IFR_MID_OP, &(GetObjBinAddr())->Header) {
SetLineNo (LineNo);
}
};
class CIfrToken : public CIfrObj, public CIfrOpHeader {
-private:
- EFI_IFR_TOKEN *mToken;
-
public:
CIfrToken (
IN UINT32 LineNo
- ) : CIfrObj (EFI_IFR_TOKEN_OP, (CHAR8 **)&mToken),
- CIfrOpHeader (EFI_IFR_TOKEN_OP, &mToken->Header) {
+ ) : CIfrObj (EFI_IFR_TOKEN_OP),
+ CIfrOpHeader (EFI_IFR_TOKEN_OP, &(GetObjBinAddr())->Header) {
SetLineNo (LineNo);
}
};
@@ -2338,8 +2763,8 @@ private:
public:
CIfrSpan (
IN UINT32 LineNo
- ) : CIfrObj (EFI_IFR_SPAN_OP, (CHAR8 **)&mSpan),
- CIfrOpHeader (EFI_IFR_SPAN_OP, &mSpan->Header) {
+ ) : CIfrObj (EFI_IFR_SPAN_OP),
+ CIfrOpHeader (EFI_IFR_SPAN_OP, &(GetObjBinAddr())->Header), mSpan(GetObjBinAddr()) {
SetLineNo (LineNo);
mSpan->Flags = EFI_IFR_FLAGS_FIRST_MATCHING;
}