\r
The definition of CFormPkg's member function\r
\r
-Copyright (c) 2004 - 2014, Intel Corporation. All rights reserved.<BR>\r
+Copyright (c) 2004 - 2017, Intel Corporation. All rights reserved.<BR>\r
This program and the accompanying materials \r
are licensed and made available under the terms and conditions of the BSD License \r
which accompanies this distribution. The full text of the license may be found at \r
VOID SetAddrAndLen (IN VOID *, IN UINT32);\r
VOID AssignValue (IN VOID *, IN UINT32);\r
CHAR8 * GetKey (VOID);\r
+\r
+private:\r
+ SPendingAssign (IN CONST SPendingAssign&); // Prevent copy-construction\r
+ SPendingAssign& operator= (IN CONST SPendingAssign&); // Prevent assignment\r
};\r
\r
struct SBufferNode {\r
EFI_VFR_RETURN_CODE BuildPkg (OUT PACKAGE_DATA &);\r
EFI_VFR_RETURN_CODE GenCFile (IN CHAR8 *, IN FILE *, IN PACKAGE_DATA *PkgData = NULL);\r
\r
+private:\r
+ CFormPkg (IN CONST CFormPkg&); // Prevent copy-construction\r
+ CFormPkg& operator= (IN CONST CFormPkg&); // Prevent assignment\r
+\r
public:\r
EFI_VFR_RETURN_CODE AssignPending (IN CHAR8 *, IN VOID *, IN UINT32, IN UINT32, IN CONST CHAR8 *Msg = NULL);\r
VOID DoPendingAssign (IN CHAR8 *, IN VOID *, IN UINT32);\r
);\r
EFI_VFR_RETURN_CODE AdjustDynamicInsertOpcode (\r
IN CHAR8 *LastFormEndAddr,\r
- IN CHAR8 *InsertOpcodeAddr\r
+ IN CHAR8 *InsertOpcodeAddr,\r
+ IN BOOLEAN CreateOpcodeAfterParsingVfr\r
);\r
CHAR8 * GetBufAddrBaseOnOffset (\r
IN UINT32 Offset\r
~SIfrRecord (VOID);\r
};\r
\r
+\r
#define EFI_IFR_RECORDINFO_IDX_INVALUD 0xFFFFFF\r
#define EFI_IFR_RECORDINFO_IDX_START 0x0\r
+#define EFI_HII_MAX_SUPPORT_DEFAULT_TYPE 0x08\r
+\r
+struct QuestionDefaultRecord {\r
+ BOOLEAN mIsDefaultIdExist[EFI_HII_MAX_SUPPORT_DEFAULT_TYPE]; // Record the default id in mAllDefaultIdArray[EFI_HII_MAX_SUPPORT_DEFAULT_TYPE]\r
+ // whether exists in current question.\r
+\r
+ SIfrRecord *mDefaultValueRecord; // Point to the default value record in RecordList which has smallest default Id.\r
+ // (for checkbox it may be NULL, because the dedault value is always true when the flag is set.)\r
+\r
+ BOOLEAN mIsDefaultOpcode; // whether the default value with smallest default id is given by default opcode.\r
+ // (for oneof and checkbox default info may be given by flag.)\r
+\r
+ UINT16 mDefaultNumber; // The default number of this question.\r
+};\r
\r
class CIfrRecordInfoDB {\r
private:\r
UINT32 mRecordCount;\r
SIfrRecord *mIfrRecordListHead;\r
SIfrRecord *mIfrRecordListTail;\r
+ UINT8 mAllDefaultTypeCount;\r
+ UINT16 mAllDefaultIdArray[EFI_HII_MAX_SUPPORT_DEFAULT_TYPE];\r
\r
SIfrRecord * GetRecordInfoFromIdx (IN UINT32);\r
BOOLEAN CheckQuestionOpCode (IN UINT8);\r
\r
SIfrRecord * GetRecordInfoFromOffset (IN UINT32);\r
VOID IfrAdjustOffsetForRecord (VOID);\r
- BOOLEAN IfrAdjustDynamicOpcodeInRecords (VOID);\r
+ BOOLEAN IfrAdjustDynamicOpcodeInRecords (IN BOOLEAN);\r
\r
UINT32 IfrRecordRegister (IN UINT32, IN CHAR8 *, IN UINT8, IN UINT32);\r
VOID IfrRecordInfoUpdate (IN UINT32, IN UINT32, IN CHAR8*, IN UINT8, IN UINT32);\r
VOID IfrRecordOutput (IN FILE *, IN UINT32 LineNo);\r
VOID IfrRecordOutput (OUT PACKAGE_DATA &);\r
- EFI_VFR_RETURN_CODE IfrRecordAdjust (VOID); \r
+ EFI_VFR_RETURN_CODE IfrRecordAdjust (VOID);\r
+ VOID IfrUpdateRecordInfoForDynamicOpcode (IN BOOLEAN);\r
+ VOID IfrCheckAddDefaultRecord (IN BOOLEAN, IN BOOLEAN);\r
+ VOID IfrGetDefaultStoreInfo ();\r
+ VOID IfrCreateDefaultRecord (IN UINT8 Size,IN UINT16 DefaultId,IN UINT8 Type,IN UINT32 LineNo,IN EFI_IFR_TYPE_VALUE Value);\r
+ VOID IfrCreateDefaultForQuestion (IN SIfrRecord *, IN QuestionDefaultRecord *);\r
+ VOID IfrParseDefaulInfoInQuestion (IN SIfrRecord *, OUT QuestionDefaultRecord *);\r
+ VOID IfrAddDefaultToBufferConfig (IN UINT16, IN SIfrRecord *,IN EFI_IFR_TYPE_VALUE);\r
+\r
+private:\r
+ CIfrRecordInfoDB (IN CONST CIfrRecordInfoDB&); // Prevent copy-construction\r
+ CIfrRecordInfoDB& operator= (IN CONST CIfrRecordInfoDB&); // Prevent assignment\r
};\r
\r
extern CIfrRecordInfoDB gCIfrRecordInfoDB;\r
mLineNo = LineNo;\r
}\r
\r
- inline CHAR8 * GetObjBinAddr (VOID) {\r
- return mObjBinBuf;\r
+ template<typename T>\r
+ inline T * GetObjBinAddr (VOID) {\r
+ return reinterpret_cast<T *>(mObjBinBuf);\r
}\r
\r
inline UINT32 GetObjBinOffset (VOID) {\r
public:\r
CIfrOpHeader (IN UINT8 OpCode, IN VOID *StartAddr, IN UINT8 Length = 0);\r
CIfrOpHeader (IN CIfrOpHeader &);\r
+ CIfrOpHeader& operator=(IN CONST CIfrOpHeader &);\r
\r
VOID IncLength (UINT8 Size) {\r
if ((mHeader->Length + Size) > mHeader->Length) {\r
VOID UpdateHeader (IN EFI_IFR_OP_HEADER *Header) {\r
mHeader = Header;\r
}\r
+\r
+ UINT8 GetOpCode () {\r
+ return mHeader->OpCode;\r
+ }\r
};\r
\r
extern UINT8 gScopeCount;\r
if (_FLAG_TEST_AND_CLEAR (Flags, EFI_IFR_FLAG_RESET_REQUIRED)) {\r
mHeader->Flags |= EFI_IFR_FLAG_RESET_REQUIRED;\r
}\r
- \r
+\r
+ if (_FLAG_TEST_AND_CLEAR (Flags, EFI_IFR_FLAG_RECONNECT_REQUIRED)) {\r
+ mHeader->Flags |= EFI_IFR_FLAG_RECONNECT_REQUIRED;\r
+ }\r
+\r
//\r
// Set LateCheck Flag to compatible for framework flag\r
// but it uses 0x20 as its flag, if in the future UEFI may take this flag\r
mMinMaxStepData->u8.Step = Step;\r
}\r
\r
- UINT64 GetMinData (UINT8 VarType) {\r
+ UINT64 GetMinData (UINT8 VarType, BOOLEAN IsBitVar) {\r
UINT64 MinValue = 0;\r
+ if (IsBitVar) {\r
+ MinValue = mMinMaxStepData->u32.MinValue;\r
+ return MinValue;\r
+ }\r
switch (VarType) {\r
case EFI_IFR_TYPE_NUM_SIZE_64:\r
MinValue = mMinMaxStepData->u64.MinValue;\r
return MinValue;\r
}\r
\r
- UINT64 GetMaxData (UINT8 VarType) {\r
+ UINT64 GetMaxData (UINT8 VarType, BOOLEAN IsBitVar) {\r
UINT64 MaxValue = 0;\r
+ if (IsBitVar) {\r
+ MaxValue = mMinMaxStepData->u32.MaxValue;\r
+ return MaxValue;\r
+ }\r
switch (VarType) {\r
case EFI_IFR_TYPE_NUM_SIZE_64:\r
MaxValue = mMinMaxStepData->u64.MaxValue;\r
return MaxValue;\r
}\r
\r
- UINT64 GetStepData (UINT8 VarType) {\r
+ UINT64 GetStepData (UINT8 VarType, BOOLEAN IsBitVar) {\r
UINT64 MaxValue = 0;\r
+ if (IsBitVar) {\r
+ MaxValue = mMinMaxStepData->u32.Step;\r
+ return MaxValue;\r
+ }\r
switch (VarType) {\r
case EFI_IFR_TYPE_NUM_SIZE_64:\r
MaxValue = mMinMaxStepData->u64.Step;\r
\r
static CIfrQuestionHeader *gCurrentQuestion = NULL;\r
static CIfrMinMaxStepData *gCurrentMinMaxData = NULL;\r
+static BOOLEAN gIsOrderedList = FALSE;\r
+static BOOLEAN gIsStringOp = FALSE;\r
\r
/*\r
* The definition of all of the UEFI IFR Objects\r
EFI_GUID *mClassGuid;\r
\r
public:\r
- CIfrFormSet (UINT8 Size) : CIfrObj (EFI_IFR_FORM_SET_OP, (CHAR8 **)&mFormSet, Size),\r
- CIfrOpHeader (EFI_IFR_FORM_SET_OP, &mFormSet->Header, Size) {\r
+ CIfrFormSet (UINT8 Size) : CIfrObj (EFI_IFR_FORM_SET_OP, (CHAR8 **)NULL, Size),\r
+ CIfrOpHeader (EFI_IFR_FORM_SET_OP, &(GetObjBinAddr<EFI_IFR_FORM_SET>())->Header, Size), mFormSet(GetObjBinAddr<EFI_IFR_FORM_SET>()) {\r
mFormSet->Help = EFI_STRING_ID_INVALID;\r
mFormSet->FormSetTitle = EFI_STRING_ID_INVALID;\r
mFormSet->Flags = 0;\r
};\r
\r
class CIfrEnd : public CIfrObj, public CIfrOpHeader {\r
-private:\r
- EFI_IFR_END *mEnd;\r
-\r
public:\r
- CIfrEnd () : CIfrObj (EFI_IFR_END_OP, (CHAR8 **)&mEnd),\r
- CIfrOpHeader (EFI_IFR_END_OP, &mEnd->Header) {}\r
+ CIfrEnd () : CIfrObj (EFI_IFR_END_OP),\r
+ CIfrOpHeader (EFI_IFR_END_OP, &(GetObjBinAddr<EFI_IFR_END>())->Header) {}\r
};\r
\r
class CIfrDefaultStore : public CIfrObj, public CIfrOpHeader {\r
EFI_IFR_DEFAULTSTORE *mDefaultStore;\r
\r
public:\r
- CIfrDefaultStore () : CIfrObj (EFI_IFR_DEFAULTSTORE_OP, (CHAR8 **)&mDefaultStore),\r
- CIfrOpHeader (EFI_IFR_DEFAULTSTORE_OP, &mDefaultStore->Header) {\r
+ CIfrDefaultStore () : CIfrObj (EFI_IFR_DEFAULTSTORE_OP),\r
+ CIfrOpHeader (EFI_IFR_DEFAULTSTORE_OP, &(GetObjBinAddr<EFI_IFR_DEFAULTSTORE>())->Header), mDefaultStore(GetObjBinAddr<EFI_IFR_DEFAULTSTORE>()) {\r
mDefaultStore->DefaultId = EFI_VARSTORE_ID_INVALID;\r
mDefaultStore->DefaultName = EFI_STRING_ID_INVALID;\r
}\r
EFI_IFR_FORM *mForm;\r
\r
public:\r
- CIfrForm () : CIfrObj (EFI_IFR_FORM_OP, (CHAR8 **)&mForm), \r
- CIfrOpHeader (EFI_IFR_FORM_OP, &mForm->Header) {\r
+ CIfrForm () : CIfrObj (EFI_IFR_FORM_OP),\r
+ CIfrOpHeader (EFI_IFR_FORM_OP, &(GetObjBinAddr<EFI_IFR_FORM>())->Header), mForm(GetObjBinAddr<EFI_IFR_FORM>()) {\r
mForm->FormId = 0;\r
mForm->FormTitle = EFI_STRING_ID_INVALID;\r
}\r
EFI_IFR_FORM_MAP_METHOD *mMethodMap;\r
\r
public:\r
- CIfrFormMap () : CIfrObj (EFI_IFR_FORM_MAP_OP, (CHAR8 **)&mFormMap, sizeof (EFI_IFR_FORM_MAP), TRUE), \r
- CIfrOpHeader (EFI_IFR_FORM_MAP_OP, &mFormMap->Header) {\r
+ CIfrFormMap () : CIfrObj (EFI_IFR_FORM_MAP_OP, (CHAR8 **)NULL, sizeof (EFI_IFR_FORM_MAP), TRUE),\r
+ CIfrOpHeader (EFI_IFR_FORM_MAP_OP, &(GetObjBinAddr<EFI_IFR_FORM_MAP>())->Header), mFormMap(GetObjBinAddr<EFI_IFR_FORM_MAP>()) {\r
mFormMap->FormId = 0;\r
mMethodMap = (EFI_IFR_FORM_MAP_METHOD *) (mFormMap + 1);\r
}\r
EFI_IFR_VARSTORE *mVarStore;\r
\r
public:\r
- CIfrVarStore () : CIfrObj (EFI_IFR_VARSTORE_OP, (CHAR8 **)&mVarStore, sizeof (EFI_IFR_VARSTORE), TRUE), \r
- CIfrOpHeader (EFI_IFR_VARSTORE_OP, &mVarStore->Header) {\r
+ CIfrVarStore () : CIfrObj (EFI_IFR_VARSTORE_OP, (CHAR8 **)NULL, sizeof (EFI_IFR_VARSTORE), TRUE),\r
+ CIfrOpHeader (EFI_IFR_VARSTORE_OP, &(GetObjBinAddr<EFI_IFR_VARSTORE>())->Header), mVarStore(GetObjBinAddr<EFI_IFR_VARSTORE>()) {\r
mVarStore->VarStoreId = EFI_VARSTORE_ID_INVALID;\r
mVarStore->Size = 0;\r
memset (&mVarStore->Guid, 0, sizeof (EFI_GUID));\r
EFI_IFR_VARSTORE_EFI *mVarStoreEfi;\r
\r
public:\r
- CIfrVarStoreEfi () : CIfrObj (EFI_IFR_VARSTORE_EFI_OP, (CHAR8 **)&mVarStoreEfi, sizeof (EFI_IFR_VARSTORE_EFI), TRUE),\r
- CIfrOpHeader (EFI_IFR_VARSTORE_EFI_OP, &mVarStoreEfi->Header) {\r
+ CIfrVarStoreEfi () : CIfrObj (EFI_IFR_VARSTORE_EFI_OP, (CHAR8 **)NULL, sizeof (EFI_IFR_VARSTORE_EFI), TRUE),\r
+ CIfrOpHeader (EFI_IFR_VARSTORE_EFI_OP, &(GetObjBinAddr<EFI_IFR_VARSTORE_EFI>())->Header), mVarStoreEfi(GetObjBinAddr<EFI_IFR_VARSTORE_EFI>()) {\r
mVarStoreEfi->VarStoreId = EFI_VAROFFSET_INVALID;\r
mVarStoreEfi->Size = 0;\r
memset (&mVarStoreEfi->Guid, 0, sizeof (EFI_GUID));\r
EFI_IFR_VARSTORE_NAME_VALUE *mVarStoreNameValue;\r
\r
public:\r
- CIfrVarStoreNameValue () : CIfrObj (EFI_IFR_VARSTORE_NAME_VALUE_OP, (CHAR8 **)&mVarStoreNameValue), \r
- CIfrOpHeader (EFI_IFR_VARSTORE_NAME_VALUE_OP, &mVarStoreNameValue->Header) {\r
+ CIfrVarStoreNameValue () : CIfrObj (EFI_IFR_VARSTORE_NAME_VALUE_OP),\r
+ CIfrOpHeader (EFI_IFR_VARSTORE_NAME_VALUE_OP, &(GetObjBinAddr<EFI_IFR_VARSTORE_NAME_VALUE>())->Header), mVarStoreNameValue(GetObjBinAddr<EFI_IFR_VARSTORE_NAME_VALUE>()) {\r
mVarStoreNameValue->VarStoreId = EFI_VAROFFSET_INVALID;\r
memset (&mVarStoreNameValue->Guid, 0, sizeof (EFI_GUID));\r
}\r
EFI_IFR_IMAGE *mImage;\r
\r
public:\r
- CIfrImage () : CIfrObj (EFI_IFR_IMAGE_OP, (CHAR8 **)&mImage),\r
- CIfrOpHeader (EFI_IFR_IMAGE_OP, &mImage->Header) {\r
+ CIfrImage () : CIfrObj (EFI_IFR_IMAGE_OP),\r
+ CIfrOpHeader (EFI_IFR_IMAGE_OP, &(GetObjBinAddr<EFI_IFR_IMAGE>())->Header), mImage(GetObjBinAddr<EFI_IFR_IMAGE>()) {\r
mImage->Id = EFI_IMAGE_ID_INVALID;\r
}\r
\r
};\r
\r
class CIfrModal : public CIfrObj, public CIfrOpHeader {\r
-private:\r
- EFI_IFR_MODAL_TAG *mModal;\r
-\r
public:\r
- CIfrModal () : CIfrObj (EFI_IFR_MODAL_TAG_OP, (CHAR8 **)&mModal),\r
- CIfrOpHeader (EFI_IFR_MODAL_TAG_OP, &mModal->Header) {\r
+ CIfrModal () : CIfrObj (EFI_IFR_MODAL_TAG_OP),\r
+ CIfrOpHeader (EFI_IFR_MODAL_TAG_OP, &(GetObjBinAddr<EFI_IFR_MODAL_TAG>())->Header) {\r
}\r
};\r
\r
\r
class CIfrLocked : public CIfrObj, public CIfrOpHeader {\r
-private:\r
- EFI_IFR_LOCKED *mLocked;\r
-\r
public:\r
- CIfrLocked () : CIfrObj (EFI_IFR_LOCKED_OP, (CHAR8 **)&mLocked),\r
- CIfrOpHeader (EFI_IFR_LOCKED_OP, &mLocked->Header) {}\r
+ CIfrLocked () : CIfrObj (EFI_IFR_LOCKED_OP),\r
+ CIfrOpHeader (EFI_IFR_LOCKED_OP, &(GetObjBinAddr<EFI_IFR_LOCKED>())->Header) {}\r
};\r
\r
class CIfrRule : public CIfrObj, public CIfrOpHeader {\r
EFI_IFR_RULE *mRule;\r
\r
public:\r
- CIfrRule () : CIfrObj (EFI_IFR_RULE_OP, (CHAR8 **)&mRule),\r
- mRule ((EFI_IFR_RULE *)GetObjBinAddr()),\r
- CIfrOpHeader (EFI_IFR_RULE_OP, &mRule->Header) {\r
+ CIfrRule () : CIfrObj (EFI_IFR_RULE_OP),\r
+ CIfrOpHeader (EFI_IFR_RULE_OP, &(GetObjBinAddr<EFI_IFR_RULE>())->Header), mRule(GetObjBinAddr<EFI_IFR_RULE>()) {\r
mRule->RuleId = EFI_RULE_ID_INVALID;\r
}\r
\r
IN UINT16 DefaultId = EFI_HII_DEFAULT_CLASS_STANDARD,\r
IN UINT8 Type = EFI_IFR_TYPE_OTHER,\r
IN EFI_IFR_TYPE_VALUE Value = gZeroEfiIfrTypeValue\r
- ) : CIfrObj (EFI_IFR_DEFAULT_OP, (CHAR8 **)&mDefault, Size),\r
- CIfrOpHeader (EFI_IFR_DEFAULT_OP, &mDefault->Header, Size) {\r
+ ) : CIfrObj (EFI_IFR_DEFAULT_OP, (CHAR8 **)NULL, Size),\r
+ CIfrOpHeader (EFI_IFR_DEFAULT_OP, &(GetObjBinAddr<EFI_IFR_DEFAULT>())->Header, Size), mDefault(GetObjBinAddr<EFI_IFR_DEFAULT>()) {\r
mDefault->Type = Type;\r
mDefault->DefaultId = DefaultId;\r
memmove (&(mDefault->Value), &Value, Size - OFFSET_OF (EFI_IFR_DEFAULT, Value));\r
CIfrDefault2 (\r
IN UINT16 DefaultId = EFI_HII_DEFAULT_CLASS_STANDARD,\r
IN UINT8 Type = EFI_IFR_TYPE_OTHER\r
- ) : CIfrObj (EFI_IFR_DEFAULT_OP, (CHAR8 **)&mDefault, sizeof (EFI_IFR_DEFAULT_2)),\r
- CIfrOpHeader (EFI_IFR_DEFAULT_OP, &mDefault->Header, sizeof (EFI_IFR_DEFAULT_2)) {\r
+ ) : CIfrObj (EFI_IFR_DEFAULT_OP, (CHAR8 **)NULL, sizeof (EFI_IFR_DEFAULT_2)),\r
+ CIfrOpHeader (EFI_IFR_DEFAULT_OP, &(GetObjBinAddr<EFI_IFR_DEFAULT_2>())->Header, sizeof (EFI_IFR_DEFAULT_2)), mDefault(GetObjBinAddr<EFI_IFR_DEFAULT_2>()) {\r
mDefault->Type = Type;\r
mDefault->DefaultId = DefaultId;\r
}\r
};\r
\r
class CIfrValue : public CIfrObj, public CIfrOpHeader{\r
-private:\r
- EFI_IFR_VALUE *mValue;\r
-\r
public:\r
- CIfrValue () : CIfrObj (EFI_IFR_VALUE_OP, (CHAR8 **)&mValue),\r
- CIfrOpHeader (EFI_IFR_VALUE_OP, &mValue->Header) {}\r
+ CIfrValue () : CIfrObj (EFI_IFR_VALUE_OP),\r
+ CIfrOpHeader (EFI_IFR_VALUE_OP, &(GetObjBinAddr<EFI_IFR_VALUE>())->Header) {}\r
\r
};\r
\r
class CIfrRead : public CIfrObj, public CIfrOpHeader{\r
-private:\r
- EFI_IFR_READ *mRead;\r
-\r
public:\r
- CIfrRead () : CIfrObj (EFI_IFR_READ_OP, (CHAR8 **)&mRead),\r
- CIfrOpHeader (EFI_IFR_READ_OP, &mRead->Header) {}\r
+ CIfrRead () : CIfrObj (EFI_IFR_READ_OP),\r
+ CIfrOpHeader (EFI_IFR_READ_OP, &(GetObjBinAddr<EFI_IFR_READ>())->Header) {}\r
\r
};\r
\r
class CIfrWrite : public CIfrObj, public CIfrOpHeader{\r
-private:\r
- EFI_IFR_WRITE *mWrite;\r
-\r
public:\r
- CIfrWrite () : CIfrObj (EFI_IFR_WRITE_OP, (CHAR8 **)&mWrite),\r
- CIfrOpHeader (EFI_IFR_WRITE_OP, &mWrite->Header) {}\r
+ CIfrWrite () : CIfrObj (EFI_IFR_WRITE_OP),\r
+ CIfrOpHeader (EFI_IFR_WRITE_OP, &(GetObjBinAddr<EFI_IFR_WRITE>())->Header) {}\r
\r
};\r
\r
public:\r
CIfrGet (\r
IN UINT32 LineNo \r
- ) : CIfrObj (EFI_IFR_GET_OP, (CHAR8 **)&mGet),\r
- CIfrOpHeader (EFI_IFR_GET_OP, &mGet->Header) {\r
+ ) : CIfrObj (EFI_IFR_GET_OP),\r
+ CIfrOpHeader (EFI_IFR_GET_OP, &(GetObjBinAddr<EFI_IFR_GET>())->Header), mGet(GetObjBinAddr<EFI_IFR_GET>()) {\r
SetLineNo (LineNo);\r
}\r
\r
public:\r
CIfrSet (\r
IN UINT32 LineNo\r
- ) : CIfrObj (EFI_IFR_SET_OP, (CHAR8 **)&mSet),\r
- CIfrOpHeader (EFI_IFR_SET_OP, &mSet->Header) {\r
+ ) : CIfrObj (EFI_IFR_SET_OP),\r
+ CIfrOpHeader (EFI_IFR_SET_OP, &(GetObjBinAddr<EFI_IFR_SET>())->Header), mSet(GetObjBinAddr<EFI_IFR_SET>()) {\r
SetLineNo (LineNo);\r
}\r
\r
EFI_IFR_SUBTITLE *mSubtitle;\r
\r
public:\r
- CIfrSubtitle () : CIfrObj (EFI_IFR_SUBTITLE_OP, (CHAR8 **)&mSubtitle),\r
- CIfrOpHeader (EFI_IFR_SUBTITLE_OP, &mSubtitle->Header),\r
- CIfrStatementHeader (&mSubtitle->Statement) {\r
+ CIfrSubtitle () : CIfrObj (EFI_IFR_SUBTITLE_OP),\r
+ CIfrOpHeader (EFI_IFR_SUBTITLE_OP, &(GetObjBinAddr<EFI_IFR_SUBTITLE>())->Header),\r
+ CIfrStatementHeader (&(GetObjBinAddr<EFI_IFR_SUBTITLE>())->Statement), mSubtitle(GetObjBinAddr<EFI_IFR_SUBTITLE>()) {\r
mSubtitle->Flags = 0;\r
}\r
\r
EFI_IFR_TEXT *mText;\r
\r
public:\r
- CIfrText () : CIfrObj (EFI_IFR_TEXT_OP, (CHAR8 **)&mText),\r
- CIfrOpHeader (EFI_IFR_TEXT_OP, &mText->Header), \r
- CIfrStatementHeader (&mText->Statement) {\r
+ CIfrText () : CIfrObj (EFI_IFR_TEXT_OP),\r
+ CIfrOpHeader (EFI_IFR_TEXT_OP, &(GetObjBinAddr<EFI_IFR_TEXT>())->Header),\r
+ CIfrStatementHeader (&(GetObjBinAddr<EFI_IFR_TEXT>())->Statement), mText(GetObjBinAddr<EFI_IFR_TEXT>()) {\r
mText->TextTwo = EFI_STRING_ID_INVALID;\r
}\r
\r
EFI_IFR_REF *mRef;\r
\r
public:\r
- CIfrRef () : CIfrObj (EFI_IFR_REF_OP, (CHAR8 **)&mRef),\r
- CIfrOpHeader (EFI_IFR_REF_OP, &mRef->Header), \r
- CIfrQuestionHeader (&mRef->Question) {\r
+ CIfrRef () : CIfrObj (EFI_IFR_REF_OP),\r
+ CIfrOpHeader (EFI_IFR_REF_OP, &(GetObjBinAddr<EFI_IFR_REF>())->Header),\r
+ CIfrQuestionHeader (&(GetObjBinAddr<EFI_IFR_REF>())->Question), mRef(GetObjBinAddr<EFI_IFR_REF>()) {\r
mRef->FormId = 0;\r
}\r
\r
EFI_IFR_REF2 *mRef2;\r
\r
public:\r
- CIfrRef2 () : CIfrObj (EFI_IFR_REF_OP, (CHAR8 **)&mRef2, sizeof (EFI_IFR_REF2)),\r
- CIfrOpHeader (EFI_IFR_REF_OP, &mRef2->Header, sizeof (EFI_IFR_REF2)), \r
- CIfrQuestionHeader (&mRef2->Question) {\r
+ CIfrRef2 () : CIfrObj (EFI_IFR_REF_OP, (CHAR8 **)NULL, sizeof (EFI_IFR_REF2)),\r
+ CIfrOpHeader (EFI_IFR_REF_OP, &(GetObjBinAddr<EFI_IFR_REF2>())->Header, sizeof (EFI_IFR_REF2)),\r
+ CIfrQuestionHeader (&(GetObjBinAddr<EFI_IFR_REF2>())->Question), mRef2(GetObjBinAddr<EFI_IFR_REF2>()) {\r
mRef2->FormId = 0;\r
mRef2->QuestionId = EFI_QUESTION_ID_INVALID;\r
}\r
EFI_IFR_REF3 *mRef3;\r
\r
public:\r
- CIfrRef3 () : CIfrObj (EFI_IFR_REF_OP, (CHAR8 **)&mRef3, sizeof(EFI_IFR_REF3)),\r
- CIfrOpHeader (EFI_IFR_REF_OP, &mRef3->Header, sizeof (EFI_IFR_REF3)), \r
- CIfrQuestionHeader (&mRef3->Question) {\r
+ CIfrRef3 () : CIfrObj (EFI_IFR_REF_OP, (CHAR8 **)NULL, sizeof(EFI_IFR_REF3)),\r
+ CIfrOpHeader (EFI_IFR_REF_OP, &(GetObjBinAddr<EFI_IFR_REF3>())->Header, sizeof (EFI_IFR_REF3)),\r
+ CIfrQuestionHeader (&(GetObjBinAddr<EFI_IFR_REF3>())->Question), mRef3(GetObjBinAddr<EFI_IFR_REF3>()) {\r
mRef3->FormId = 0;\r
mRef3->QuestionId = EFI_QUESTION_ID_INVALID;\r
memset (&mRef3->FormSetId, 0, sizeof (EFI_GUID));\r
EFI_IFR_REF4 *mRef4;\r
\r
public:\r
- CIfrRef4 () : CIfrObj (EFI_IFR_REF_OP, (CHAR8 **)&mRef4, sizeof(EFI_IFR_REF4)),\r
- CIfrOpHeader (EFI_IFR_REF_OP, &mRef4->Header, sizeof(EFI_IFR_REF4)), \r
- CIfrQuestionHeader (&mRef4->Question) {\r
+ CIfrRef4 () : CIfrObj (EFI_IFR_REF_OP, (CHAR8 **)NULL, sizeof(EFI_IFR_REF4)),\r
+ CIfrOpHeader (EFI_IFR_REF_OP, &(GetObjBinAddr<EFI_IFR_REF4>())->Header, sizeof(EFI_IFR_REF4)),\r
+ CIfrQuestionHeader (&(GetObjBinAddr<EFI_IFR_REF4>())->Question), mRef4(GetObjBinAddr<EFI_IFR_REF4>()) {\r
mRef4->FormId = 0;\r
mRef4->QuestionId = EFI_QUESTION_ID_INVALID;\r
memset (&mRef4->FormSetId, 0, sizeof (EFI_GUID));\r
};\r
\r
class CIfrRef5 : public CIfrObj, public CIfrOpHeader, public CIfrQuestionHeader {\r
-private:\r
- EFI_IFR_REF5 *mRef5;\r
-\r
public:\r
- CIfrRef5 () : CIfrObj (EFI_IFR_REF_OP, (CHAR8 **)&mRef5, sizeof (EFI_IFR_REF5)),\r
- CIfrOpHeader (EFI_IFR_REF_OP, &mRef5->Header, sizeof (EFI_IFR_REF5)), \r
- CIfrQuestionHeader (&mRef5->Question) {\r
+ CIfrRef5 () : CIfrObj (EFI_IFR_REF_OP, (CHAR8 **)NULL, sizeof (EFI_IFR_REF5)),\r
+ CIfrOpHeader (EFI_IFR_REF_OP, &(GetObjBinAddr<EFI_IFR_REF5>())->Header, sizeof (EFI_IFR_REF5)),\r
+ CIfrQuestionHeader (&(GetObjBinAddr<EFI_IFR_REF5>())->Question) {\r
}\r
};\r
\r
EFI_IFR_RESET_BUTTON *mResetButton;\r
\r
public:\r
- CIfrResetButton () : CIfrObj (EFI_IFR_RESET_BUTTON_OP, (CHAR8 **)&mResetButton),\r
- CIfrOpHeader (EFI_IFR_RESET_BUTTON_OP, &mResetButton->Header), \r
- CIfrStatementHeader (&mResetButton->Statement) {\r
+ CIfrResetButton () : CIfrObj (EFI_IFR_RESET_BUTTON_OP),\r
+ CIfrOpHeader (EFI_IFR_RESET_BUTTON_OP, &(GetObjBinAddr<EFI_IFR_RESET_BUTTON>())->Header),\r
+ CIfrStatementHeader (&(GetObjBinAddr<EFI_IFR_RESET_BUTTON>())->Statement), mResetButton(GetObjBinAddr<EFI_IFR_RESET_BUTTON>()) {\r
mResetButton->DefaultId = EFI_HII_DEFAULT_CLASS_STANDARD;\r
}\r
\r
EFI_IFR_CHECKBOX *mCheckBox;\r
\r
public:\r
- CIfrCheckBox () : CIfrObj (EFI_IFR_CHECKBOX_OP, (CHAR8 **)&mCheckBox),\r
- CIfrOpHeader (EFI_IFR_CHECKBOX_OP, &mCheckBox->Header), \r
- CIfrQuestionHeader (&mCheckBox->Question) {\r
+ CIfrCheckBox () : CIfrObj (EFI_IFR_CHECKBOX_OP),\r
+ CIfrOpHeader (EFI_IFR_CHECKBOX_OP, &(GetObjBinAddr<EFI_IFR_CHECKBOX>())->Header),\r
+ CIfrQuestionHeader (&(GetObjBinAddr<EFI_IFR_CHECKBOX>())->Question), mCheckBox(GetObjBinAddr<EFI_IFR_CHECKBOX>()) {\r
mCheckBox->Flags = 0;\r
gCurrentQuestion = this;\r
}\r
EFI_IFR_ACTION *mAction;\r
\r
public:\r
- CIfrAction () : CIfrObj (EFI_IFR_ACTION_OP, (CHAR8 **)&mAction),\r
- CIfrOpHeader (EFI_IFR_ACTION_OP, &mAction->Header), \r
- CIfrQuestionHeader (&mAction->Question) {\r
+ CIfrAction () : CIfrObj (EFI_IFR_ACTION_OP),\r
+ CIfrOpHeader (EFI_IFR_ACTION_OP, &(GetObjBinAddr<EFI_IFR_ACTION>())->Header),\r
+ CIfrQuestionHeader (&(GetObjBinAddr<EFI_IFR_ACTION>())->Question), mAction(GetObjBinAddr<EFI_IFR_ACTION>()) {\r
mAction->QuestionConfig = EFI_STRING_ID_INVALID;\r
}\r
\r
EFI_IFR_DATE *mDate;\r
\r
public:\r
- CIfrDate () : CIfrObj (EFI_IFR_DATE_OP, (CHAR8 **)&mDate),\r
- CIfrOpHeader (EFI_IFR_DATE_OP, &mDate->Header),\r
- CIfrQuestionHeader (&mDate->Question) {\r
+ CIfrDate () : CIfrObj (EFI_IFR_DATE_OP),\r
+ CIfrOpHeader (EFI_IFR_DATE_OP, &(GetObjBinAddr<EFI_IFR_DATE>())->Header),\r
+ CIfrQuestionHeader (&(GetObjBinAddr<EFI_IFR_DATE>())->Question), mDate(GetObjBinAddr<EFI_IFR_DATE>()) {\r
mDate->Flags = 0;\r
}\r
\r
EFI_IFR_NUMERIC *mNumeric;\r
\r
public:\r
- CIfrNumeric () : CIfrObj (EFI_IFR_NUMERIC_OP, (CHAR8 **)&mNumeric, sizeof (EFI_IFR_NUMERIC), TRUE),\r
- CIfrOpHeader (EFI_IFR_NUMERIC_OP, &mNumeric->Header),\r
- CIfrQuestionHeader (&mNumeric->Question),\r
- CIfrMinMaxStepData (&mNumeric->data, TRUE) {\r
+ CIfrNumeric () : CIfrObj (EFI_IFR_NUMERIC_OP, (CHAR8 **)NULL, sizeof (EFI_IFR_NUMERIC), TRUE),\r
+ CIfrOpHeader (EFI_IFR_NUMERIC_OP, &(GetObjBinAddr<EFI_IFR_NUMERIC>())->Header),\r
+ CIfrQuestionHeader (&(GetObjBinAddr<EFI_IFR_NUMERIC>())->Question),\r
+ CIfrMinMaxStepData (&(GetObjBinAddr<EFI_IFR_NUMERIC>())->data, TRUE), mNumeric(GetObjBinAddr<EFI_IFR_NUMERIC>()) {\r
mNumeric->Flags = EFI_IFR_NUMERIC_SIZE_1 | EFI_IFR_DISPLAY_UINT_DEC;\r
gCurrentQuestion = this;\r
gCurrentMinMaxData = this;\r
//\r
// Update the buffer pointer used by other class.\r
//\r
- mNumeric = (EFI_IFR_NUMERIC *) GetObjBinAddr();\r
+ mNumeric = GetObjBinAddr<EFI_IFR_NUMERIC>();\r
UpdateHeader (&mNumeric->Header);\r
UpdateCIfrQuestionHeader(&mNumeric->Question);\r
UpdateCIfrMinMaxStepData(&mNumeric->data);\r
}\r
return VFR_RETURN_SUCCESS;\r
}\r
+\r
+ EFI_VFR_RETURN_CODE SetFlagsForBitField (IN UINT8 HFlags, IN UINT8 LFlags, BOOLEAN DisplaySettingsSpecified = FALSE) {\r
+ EFI_VFR_RETURN_CODE Ret;\r
+\r
+ Ret = CIfrQuestionHeader::SetFlags (HFlags);\r
+ if (Ret != VFR_RETURN_SUCCESS) {\r
+ return Ret;\r
+ }\r
+\r
+ if (DisplaySettingsSpecified == FALSE) {\r
+ mNumeric->Flags = LFlags | EDKII_IFR_DISPLAY_UINT_DEC_BIT;\r
+ } else {\r
+ mNumeric->Flags = LFlags;\r
+ }\r
+ return VFR_RETURN_SUCCESS;\r
+ }\r
+\r
+ UINT8 GetNumericFlags () {\r
+ return mNumeric->Flags;\r
+ }\r
};\r
\r
class CIfrOneOf : public CIfrObj, public CIfrOpHeader, public CIfrQuestionHeader, public CIfrMinMaxStepData {\r
EFI_IFR_ONE_OF *mOneOf;\r
\r
public:\r
- CIfrOneOf () : CIfrObj (EFI_IFR_ONE_OF_OP, (CHAR8 **)&mOneOf, sizeof (EFI_IFR_ONE_OF), TRUE),\r
- CIfrOpHeader (EFI_IFR_ONE_OF_OP, &mOneOf->Header),\r
- CIfrQuestionHeader (&mOneOf->Question),\r
- CIfrMinMaxStepData (&mOneOf->data) {\r
+ CIfrOneOf () : CIfrObj (EFI_IFR_ONE_OF_OP, (CHAR8 **)NULL, sizeof (EFI_IFR_ONE_OF), TRUE),\r
+ CIfrOpHeader (EFI_IFR_ONE_OF_OP, &(GetObjBinAddr<EFI_IFR_ONE_OF>())->Header),\r
+ CIfrQuestionHeader (&(GetObjBinAddr<EFI_IFR_ONE_OF>())->Question),\r
+ CIfrMinMaxStepData (&(GetObjBinAddr<EFI_IFR_ONE_OF>())->data), mOneOf(GetObjBinAddr<EFI_IFR_ONE_OF>()) {\r
mOneOf->Flags = 0;\r
gCurrentQuestion = this;\r
gCurrentMinMaxData = this;\r
return VFR_RETURN_SUCCESS;\r
}\r
\r
+ EFI_VFR_RETURN_CODE SetFlagsForBitField (IN UINT8 HFlags, IN UINT8 LFlags) {\r
+ EFI_VFR_RETURN_CODE Ret;\r
+\r
+ Ret = CIfrQuestionHeader::SetFlags (HFlags);\r
+ if (Ret != VFR_RETURN_SUCCESS) {\r
+ return Ret;\r
+ }\r
+\r
+ if (LFlags & EFI_IFR_DISPLAY) {\r
+ mOneOf->Flags = LFlags;\r
+ } else {\r
+ mOneOf->Flags = LFlags | EDKII_IFR_DISPLAY_UINT_DEC_BIT;\r
+ }\r
+ return VFR_RETURN_SUCCESS;\r
+ }\r
+\r
VOID ShrinkBinSize (IN UINT16 Size) {\r
//\r
// Update the buffer size which is truly be used later.\r
//\r
// Update the buffer pointer used by other class.\r
//\r
- mOneOf = (EFI_IFR_ONE_OF *) GetObjBinAddr();\r
+ mOneOf = GetObjBinAddr<EFI_IFR_ONE_OF>();\r
UpdateHeader (&mOneOf->Header);\r
UpdateCIfrQuestionHeader(&mOneOf->Question);\r
UpdateCIfrMinMaxStepData(&mOneOf->data);\r
EFI_IFR_STRING *mString;\r
\r
public:\r
- CIfrString () : CIfrObj (EFI_IFR_STRING_OP, (CHAR8 **)&mString),\r
- CIfrOpHeader (EFI_IFR_STRING_OP, &mString->Header),\r
- CIfrQuestionHeader (&mString->Question) {\r
+ CIfrString () : CIfrObj (EFI_IFR_STRING_OP),\r
+ CIfrOpHeader (EFI_IFR_STRING_OP, &(GetObjBinAddr<EFI_IFR_STRING>())->Header),\r
+ CIfrQuestionHeader (&(GetObjBinAddr<EFI_IFR_STRING>())->Question), mString(GetObjBinAddr<EFI_IFR_STRING>()) {\r
mString->Flags = 0;\r
mString->MinSize = 0;\r
mString->MaxSize = 0;\r
EFI_IFR_PASSWORD *mPassword;\r
\r
public:\r
- CIfrPassword () : CIfrObj (EFI_IFR_PASSWORD_OP, (CHAR8 **)&mPassword),\r
- CIfrOpHeader (EFI_IFR_PASSWORD_OP, &mPassword->Header),\r
- CIfrQuestionHeader (&mPassword->Question) {\r
+ CIfrPassword () : CIfrObj (EFI_IFR_PASSWORD_OP),\r
+ CIfrOpHeader (EFI_IFR_PASSWORD_OP, &(GetObjBinAddr<EFI_IFR_PASSWORD>())->Header),\r
+ CIfrQuestionHeader (&(GetObjBinAddr<EFI_IFR_PASSWORD>())->Question), mPassword(GetObjBinAddr<EFI_IFR_PASSWORD>()) {\r
mPassword->MinSize = 0;\r
mPassword->MaxSize = 0;\r
gCurrentQuestion = this;\r
EFI_IFR_ORDERED_LIST *mOrderedList;\r
\r
public:\r
- CIfrOrderedList () : CIfrObj (EFI_IFR_ORDERED_LIST_OP, (CHAR8 **)&mOrderedList),\r
- CIfrOpHeader (EFI_IFR_ORDERED_LIST_OP, &mOrderedList->Header),\r
- CIfrQuestionHeader (&mOrderedList->Question) {\r
+ CIfrOrderedList () : CIfrObj (EFI_IFR_ORDERED_LIST_OP),\r
+ CIfrOpHeader (EFI_IFR_ORDERED_LIST_OP, &(GetObjBinAddr<EFI_IFR_ORDERED_LIST>())->Header),\r
+ CIfrQuestionHeader (&(GetObjBinAddr<EFI_IFR_ORDERED_LIST>())->Question), mOrderedList(GetObjBinAddr<EFI_IFR_ORDERED_LIST>()) {\r
mOrderedList->MaxContainers = 0;\r
mOrderedList->Flags = 0;\r
gCurrentQuestion = this;\r
EFI_IFR_TIME *mTime;\r
\r
public:\r
- CIfrTime () : CIfrObj (EFI_IFR_TIME_OP, (CHAR8 **)&mTime),\r
- CIfrOpHeader (EFI_IFR_TIME_OP, &mTime->Header),\r
- CIfrQuestionHeader (&mTime->Question) {\r
+ CIfrTime () : CIfrObj (EFI_IFR_TIME_OP),\r
+ CIfrOpHeader (EFI_IFR_TIME_OP, &(GetObjBinAddr<EFI_IFR_TIME>())->Header),\r
+ CIfrQuestionHeader (&(GetObjBinAddr<EFI_IFR_TIME>())->Question), mTime(GetObjBinAddr<EFI_IFR_TIME>()) {\r
mTime->Flags = 0;\r
}\r
\r
};\r
\r
class CIfrDisableIf : public CIfrObj, public CIfrOpHeader {\r
-private:\r
- EFI_IFR_DISABLE_IF *mDisableIf;\r
-\r
public:\r
- CIfrDisableIf () : CIfrObj (EFI_IFR_DISABLE_IF_OP, (CHAR8 **)&mDisableIf),\r
- mDisableIf ((EFI_IFR_DISABLE_IF *) GetObjBinAddr()),\r
- CIfrOpHeader (EFI_IFR_DISABLE_IF_OP, &mDisableIf->Header) {}\r
+ CIfrDisableIf () : CIfrObj (EFI_IFR_DISABLE_IF_OP),\r
+ CIfrOpHeader (EFI_IFR_DISABLE_IF_OP, &(GetObjBinAddr<EFI_IFR_DISABLE_IF>())->Header) {}\r
};\r
\r
class CIfrSuppressIf : public CIfrObj, public CIfrOpHeader {\r
-private:\r
- EFI_IFR_SUPPRESS_IF *mSuppressIf;\r
-\r
public:\r
- CIfrSuppressIf () : CIfrObj (EFI_IFR_SUPPRESS_IF_OP, (CHAR8 **)&mSuppressIf),\r
- CIfrOpHeader (EFI_IFR_SUPPRESS_IF_OP, &mSuppressIf->Header) {}\r
+ CIfrSuppressIf () : CIfrObj (EFI_IFR_SUPPRESS_IF_OP),\r
+ CIfrOpHeader (EFI_IFR_SUPPRESS_IF_OP, &(GetObjBinAddr<EFI_IFR_SUPPRESS_IF>())->Header) {}\r
};\r
\r
class CIfrGrayOutIf : public CIfrObj, public CIfrOpHeader {\r
-private:\r
- EFI_IFR_GRAY_OUT_IF *mGrayOutIf;\r
-\r
public:\r
- CIfrGrayOutIf () : CIfrObj (EFI_IFR_GRAY_OUT_IF_OP, (CHAR8 **)&mGrayOutIf),\r
- CIfrOpHeader (EFI_IFR_GRAY_OUT_IF_OP, &mGrayOutIf->Header) {}\r
+ CIfrGrayOutIf () : CIfrObj (EFI_IFR_GRAY_OUT_IF_OP),\r
+ CIfrOpHeader (EFI_IFR_GRAY_OUT_IF_OP, &(GetObjBinAddr<EFI_IFR_GRAY_OUT_IF>())->Header) {}\r
};\r
\r
class CIfrInconsistentIf : public CIfrObj, public CIfrOpHeader {\r
EFI_IFR_INCONSISTENT_IF *mInconsistentIf;\r
\r
public:\r
- CIfrInconsistentIf () : CIfrObj (EFI_IFR_INCONSISTENT_IF_OP, (CHAR8 **)&mInconsistentIf),\r
- CIfrOpHeader (EFI_IFR_INCONSISTENT_IF_OP, &mInconsistentIf->Header) {\r
+ CIfrInconsistentIf () : CIfrObj (EFI_IFR_INCONSISTENT_IF_OP),\r
+ CIfrOpHeader (EFI_IFR_INCONSISTENT_IF_OP, &(GetObjBinAddr<EFI_IFR_INCONSISTENT_IF>())->Header), mInconsistentIf(GetObjBinAddr<EFI_IFR_INCONSISTENT_IF>()) {\r
mInconsistentIf->Error = EFI_STRING_ID_INVALID;\r
}\r
\r
EFI_IFR_WARNING_IF *mWarningIf;\r
\r
public:\r
- CIfrWarningIf () : CIfrObj (EFI_IFR_WARNING_IF_OP, (CHAR8 **)&mWarningIf),\r
- CIfrOpHeader (EFI_IFR_WARNING_IF_OP, &mWarningIf->Header) {\r
+ CIfrWarningIf () : CIfrObj (EFI_IFR_WARNING_IF_OP),\r
+ CIfrOpHeader (EFI_IFR_WARNING_IF_OP, &(GetObjBinAddr<EFI_IFR_WARNING_IF>())->Header), mWarningIf(GetObjBinAddr<EFI_IFR_WARNING_IF>()) {\r
mWarningIf->Warning = EFI_STRING_ID_INVALID;\r
mWarningIf->TimeOut = 0;\r
}\r
EFI_IFR_NO_SUBMIT_IF *mNoSubmitIf;\r
\r
public:\r
- CIfrNoSubmitIf () : CIfrObj (EFI_IFR_NO_SUBMIT_IF_OP, (CHAR8 **)&mNoSubmitIf),\r
- CIfrOpHeader (EFI_IFR_NO_SUBMIT_IF_OP, &mNoSubmitIf->Header) {\r
+ CIfrNoSubmitIf () : CIfrObj (EFI_IFR_NO_SUBMIT_IF_OP),\r
+ CIfrOpHeader (EFI_IFR_NO_SUBMIT_IF_OP, &(GetObjBinAddr<EFI_IFR_NO_SUBMIT_IF>())->Header), mNoSubmitIf(GetObjBinAddr<EFI_IFR_NO_SUBMIT_IF>()) {\r
mNoSubmitIf->Error = EFI_STRING_ID_INVALID;\r
}\r
\r
EFI_IFR_REFRESH *mRefresh;\r
\r
public:\r
- CIfrRefresh () : CIfrObj (EFI_IFR_REFRESH_OP, (CHAR8 **)&mRefresh),\r
- CIfrOpHeader (EFI_IFR_REFRESH_OP, &mRefresh->Header) {\r
+ CIfrRefresh () : CIfrObj (EFI_IFR_REFRESH_OP),\r
+ CIfrOpHeader (EFI_IFR_REFRESH_OP, &(GetObjBinAddr<EFI_IFR_REFRESH>())->Header), mRefresh(GetObjBinAddr<EFI_IFR_REFRESH>()) {\r
mRefresh->RefreshInterval = 0;\r
}\r
\r
EFI_IFR_REFRESH_ID *mRefreshId;\r
\r
public:\r
- CIfrRefreshId () : CIfrObj (EFI_IFR_REFRESH_ID_OP, (CHAR8 **)&mRefreshId),\r
- CIfrOpHeader (EFI_IFR_REFRESH_ID_OP, &mRefreshId->Header) {\r
+ CIfrRefreshId () : CIfrObj (EFI_IFR_REFRESH_ID_OP),\r
+ CIfrOpHeader (EFI_IFR_REFRESH_ID_OP, &(GetObjBinAddr<EFI_IFR_REFRESH_ID>())->Header), mRefreshId(GetObjBinAddr<EFI_IFR_REFRESH_ID>()) {\r
memset (&mRefreshId->RefreshEventGroupId, 0, sizeof (EFI_GUID));\r
}\r
\r
EFI_IFR_VARSTORE_DEVICE *mVarStoreDevice;\r
\r
public:\r
- CIfrVarStoreDevice () : CIfrObj (EFI_IFR_VARSTORE_DEVICE_OP, (CHAR8 **)&mVarStoreDevice),\r
- CIfrOpHeader (EFI_IFR_VARSTORE_DEVICE_OP, &mVarStoreDevice->Header) {\r
+ CIfrVarStoreDevice () : CIfrObj (EFI_IFR_VARSTORE_DEVICE_OP),\r
+ CIfrOpHeader (EFI_IFR_VARSTORE_DEVICE_OP, &(GetObjBinAddr<EFI_IFR_VARSTORE_DEVICE>())->Header), mVarStoreDevice(GetObjBinAddr<EFI_IFR_VARSTORE_DEVICE>()) {\r
mVarStoreDevice->DevicePath = EFI_STRING_ID_INVALID;\r
}\r
\r
EFI_IFR_ONE_OF_OPTION *mOneOfOption;\r
\r
public:\r
- CIfrOneOfOption (UINT8 Size) : CIfrObj (EFI_IFR_ONE_OF_OPTION_OP, (CHAR8 **)&mOneOfOption, Size),\r
- CIfrOpHeader (EFI_IFR_ONE_OF_OPTION_OP, &mOneOfOption->Header, Size) {\r
+ CIfrOneOfOption (UINT8 Size) : CIfrObj (EFI_IFR_ONE_OF_OPTION_OP, (CHAR8 **)NULL, Size),\r
+ CIfrOpHeader (EFI_IFR_ONE_OF_OPTION_OP, &(GetObjBinAddr<EFI_IFR_ONE_OF_OPTION>())->Header, Size), mOneOfOption(GetObjBinAddr<EFI_IFR_ONE_OF_OPTION>()) {\r
mOneOfOption->Flags = 0;\r
mOneOfOption->Option = EFI_STRING_ID_INVALID;\r
mOneOfOption->Type = EFI_IFR_TYPE_OTHER;\r
}\r
\r
EFI_VFR_RETURN_CODE SetFlags (IN UINT8 LFlags) {\r
+ mOneOfOption->Flags = 0;\r
if (_FLAG_TEST_AND_CLEAR (LFlags, EFI_IFR_OPTION_DEFAULT)) {\r
mOneOfOption->Flags |= EFI_IFR_OPTION_DEFAULT;\r
}\r
EFI_IFR_GUID_CLASS *mClass;\r
\r
public:\r
- CIfrClass () : CIfrObj (EFI_IFR_GUID_OP, (CHAR8 **)&mClass, sizeof (EFI_IFR_GUID_CLASS)),\r
- CIfrOpHeader (EFI_IFR_GUID_OP, &mClass->Header, sizeof (EFI_IFR_GUID_CLASS)) {\r
+ CIfrClass () : CIfrObj (EFI_IFR_GUID_OP, (CHAR8 **)NULL, sizeof (EFI_IFR_GUID_CLASS)),\r
+ CIfrOpHeader (EFI_IFR_GUID_OP, &(GetObjBinAddr<EFI_IFR_GUID_CLASS>())->Header, sizeof (EFI_IFR_GUID_CLASS)), mClass(GetObjBinAddr<EFI_IFR_GUID_CLASS>()) {\r
mClass->ExtendOpCode = EFI_IFR_EXTEND_OP_CLASS;\r
mClass->Guid = IfrTianoGuid;\r
mClass->Class = EFI_NON_DEVICE_CLASS;\r
EFI_IFR_GUID_SUBCLASS *mSubClass;\r
\r
public:\r
- CIfrSubClass () : CIfrObj (EFI_IFR_GUID_OP, (CHAR8 **)&mSubClass, sizeof (EFI_IFR_GUID_SUBCLASS)),\r
- CIfrOpHeader (EFI_IFR_GUID_OP, &mSubClass->Header, sizeof (EFI_IFR_GUID_SUBCLASS)) {\r
+ CIfrSubClass () : CIfrObj (EFI_IFR_GUID_OP, (CHAR8 **)NULL, sizeof (EFI_IFR_GUID_SUBCLASS)),\r
+ CIfrOpHeader (EFI_IFR_GUID_OP, &(GetObjBinAddr<EFI_IFR_GUID_SUBCLASS>())->Header, sizeof (EFI_IFR_GUID_SUBCLASS)), mSubClass(GetObjBinAddr<EFI_IFR_GUID_SUBCLASS>()) {\r
mSubClass->ExtendOpCode = EFI_IFR_EXTEND_OP_SUBCLASS;\r
mSubClass->Guid = IfrTianoGuid;\r
mSubClass->SubClass = EFI_SETUP_APPLICATION_SUBCLASS;\r
EFI_IFR_GUID_LABEL *mLabel;\r
\r
public:\r
- CIfrLabel () : CIfrObj (EFI_IFR_GUID_OP, (CHAR8 **)&mLabel, sizeof (EFI_IFR_GUID_LABEL)),\r
- CIfrOpHeader (EFI_IFR_GUID_OP, &mLabel->Header, sizeof (EFI_IFR_GUID_LABEL)) {\r
+ CIfrLabel () : CIfrObj (EFI_IFR_GUID_OP, (CHAR8 **)NULL, sizeof (EFI_IFR_GUID_LABEL)),\r
+ CIfrOpHeader (EFI_IFR_GUID_OP, &(GetObjBinAddr<EFI_IFR_GUID_LABEL>())->Header, sizeof (EFI_IFR_GUID_LABEL)), mLabel(GetObjBinAddr<EFI_IFR_GUID_LABEL>()) {\r
mLabel->ExtendOpCode = EFI_IFR_EXTEND_OP_LABEL;\r
mLabel->Guid = IfrTianoGuid;\r
}\r
EFI_IFR_GUID_BANNER *mBanner;\r
\r
public:\r
- CIfrBanner () : CIfrObj (EFI_IFR_GUID_OP, (CHAR8 **)&mBanner, sizeof (EFI_IFR_GUID_BANNER)),\r
- CIfrOpHeader (EFI_IFR_GUID_OP, &mBanner->Header, sizeof (EFI_IFR_GUID_BANNER)) {\r
+ CIfrBanner () : CIfrObj (EFI_IFR_GUID_OP, (CHAR8 **)NULL, sizeof (EFI_IFR_GUID_BANNER)),\r
+ CIfrOpHeader (EFI_IFR_GUID_OP, &(GetObjBinAddr<EFI_IFR_GUID_BANNER>())->Header, sizeof (EFI_IFR_GUID_BANNER)), mBanner(GetObjBinAddr<EFI_IFR_GUID_BANNER>()) {\r
mBanner->ExtendOpCode = EFI_IFR_EXTEND_OP_BANNER;\r
mBanner->Guid = IfrTianoGuid;\r
}\r
IN EFI_QUESTION_ID QuestionId,\r
IN EFI_IFR_TYPE_VALUE &OptionValue,\r
IN EFI_QUESTION_ID KeyValue\r
- ) : CIfrObj (EFI_IFR_GUID_OP, (CHAR8 **)&mOptionKey, sizeof (EFI_IFR_GUID_OPTIONKEY)),\r
- CIfrOpHeader (EFI_IFR_GUID_OP, &mOptionKey->Header, sizeof (EFI_IFR_GUID_OPTIONKEY)) {\r
+ ) : CIfrObj (EFI_IFR_GUID_OP, (CHAR8 **)NULL, sizeof (EFI_IFR_GUID_OPTIONKEY)),\r
+ CIfrOpHeader (EFI_IFR_GUID_OP, &(GetObjBinAddr<EFI_IFR_GUID_OPTIONKEY>())->Header, sizeof (EFI_IFR_GUID_OPTIONKEY)), mOptionKey(GetObjBinAddr<EFI_IFR_GUID_OPTIONKEY>()) {\r
mOptionKey->ExtendOpCode = EFI_IFR_EXTEND_OP_OPTIONKEY;\r
mOptionKey->Guid = IfrFrameworkGuid;\r
mOptionKey->QuestionId = QuestionId;\r
CIfrVarEqName (\r
IN EFI_QUESTION_ID QuestionId,\r
IN EFI_STRING_ID NameId\r
- ) : CIfrObj (EFI_IFR_GUID_OP, (CHAR8 **)&mVarEqName, sizeof (EFI_IFR_GUID_VAREQNAME)),\r
- CIfrOpHeader (EFI_IFR_GUID_OP, &mVarEqName->Header, sizeof (EFI_IFR_GUID_VAREQNAME)) {\r
+ ) : CIfrObj (EFI_IFR_GUID_OP, (CHAR8 **)NULL, sizeof (EFI_IFR_GUID_VAREQNAME)),\r
+ CIfrOpHeader (EFI_IFR_GUID_OP, &(GetObjBinAddr<EFI_IFR_GUID_VAREQNAME>())->Header, sizeof (EFI_IFR_GUID_VAREQNAME)), mVarEqName(GetObjBinAddr<EFI_IFR_GUID_VAREQNAME>()) {\r
mVarEqName->ExtendOpCode = EFI_IFR_EXTEND_OP_VAREQNAME;\r
mVarEqName->Guid = IfrFrameworkGuid;\r
mVarEqName->QuestionId = QuestionId;\r
EFI_IFR_GUID_TIMEOUT *mTimeout;\r
\r
public:\r
- CIfrTimeout (IN UINT16 Timeout = 0) : CIfrObj (EFI_IFR_GUID_OP, (CHAR8 **)&mTimeout, sizeof (EFI_IFR_GUID_TIMEOUT)),\r
- CIfrOpHeader (EFI_IFR_GUID_OP, &mTimeout->Header, sizeof (EFI_IFR_GUID_TIMEOUT)) {\r
+ CIfrTimeout (IN UINT16 Timeout = 0) : CIfrObj (EFI_IFR_GUID_OP, (CHAR8 **)NULL, sizeof (EFI_IFR_GUID_TIMEOUT)),\r
+ CIfrOpHeader (EFI_IFR_GUID_OP, &(GetObjBinAddr<EFI_IFR_GUID_TIMEOUT>())->Header, sizeof (EFI_IFR_GUID_TIMEOUT)), mTimeout(GetObjBinAddr<EFI_IFR_GUID_TIMEOUT>()) {\r
mTimeout->ExtendOpCode = EFI_IFR_EXTEND_OP_TIMEOUT;\r
mTimeout->Guid = IfrTianoGuid;\r
mTimeout->TimeOut = Timeout;\r
EFI_IFR_GUID *mGuid;\r
\r
public:\r
- CIfrGuid (UINT8 Size) : CIfrObj (EFI_IFR_GUID_OP, (CHAR8 **)&mGuid, sizeof (EFI_IFR_GUID)+Size),\r
- CIfrOpHeader (EFI_IFR_GUID_OP, &mGuid->Header, sizeof (EFI_IFR_GUID)+Size) {\r
+ CIfrGuid (UINT8 Size) : CIfrObj (EFI_IFR_GUID_OP, (CHAR8 **)NULL, sizeof (EFI_IFR_GUID)+Size),\r
+ CIfrOpHeader (EFI_IFR_GUID_OP, &(GetObjBinAddr<EFI_IFR_GUID>())->Header, sizeof (EFI_IFR_GUID)+Size), mGuid(GetObjBinAddr<EFI_IFR_GUID>()) {\r
memset (&mGuid->Guid, 0, sizeof (EFI_GUID));\r
}\r
\r
};\r
\r
class CIfrDup : public CIfrObj, public CIfrOpHeader {\r
-private:\r
- EFI_IFR_DUP *mDup;\r
-\r
public:\r
CIfrDup (\r
IN UINT32 LineNo\r
- ) : CIfrObj (EFI_IFR_DUP_OP, (CHAR8 **)&mDup),\r
- CIfrOpHeader (EFI_IFR_DUP_OP, &mDup->Header) {\r
+ ) : CIfrObj (EFI_IFR_DUP_OP),\r
+ CIfrOpHeader (EFI_IFR_DUP_OP, &(GetObjBinAddr<EFI_IFR_DUP>())->Header) {\r
SetLineNo (LineNo);\r
}\r
};\r
public:\r
CIfrEqIdId (\r
IN UINT32 LineNo\r
- ) : CIfrObj (EFI_IFR_EQ_ID_ID_OP, (CHAR8 **)&mEqIdId),\r
- CIfrOpHeader (EFI_IFR_EQ_ID_ID_OP, &mEqIdId->Header) {\r
+ ) : CIfrObj (EFI_IFR_EQ_ID_ID_OP),\r
+ CIfrOpHeader (EFI_IFR_EQ_ID_ID_OP, &(GetObjBinAddr<EFI_IFR_EQ_ID_ID>())->Header), mEqIdId(GetObjBinAddr<EFI_IFR_EQ_ID_ID>()) {\r
SetLineNo (LineNo);\r
mEqIdId->QuestionId1 = EFI_QUESTION_ID_INVALID;\r
mEqIdId->QuestionId2 = EFI_QUESTION_ID_INVALID;\r
public:\r
CIfrEqIdVal (\r
IN UINT32 LineNo\r
- ) : CIfrObj (EFI_IFR_EQ_ID_VAL_OP, (CHAR8 **)&mEqIdVal),\r
- CIfrOpHeader (EFI_IFR_EQ_ID_VAL_OP, &mEqIdVal->Header) {\r
+ ) : CIfrObj (EFI_IFR_EQ_ID_VAL_OP),\r
+ CIfrOpHeader (EFI_IFR_EQ_ID_VAL_OP, &(GetObjBinAddr<EFI_IFR_EQ_ID_VAL>())->Header), mEqIdVal(GetObjBinAddr<EFI_IFR_EQ_ID_VAL>()) {\r
SetLineNo (LineNo);\r
mEqIdVal->QuestionId = EFI_QUESTION_ID_INVALID;\r
}\r
public:\r
CIfrEqIdList (\r
IN UINT32 LineNo\r
- ) : CIfrObj (EFI_IFR_EQ_ID_VAL_LIST_OP, (CHAR8 **)&mEqIdVList, sizeof (EFI_IFR_EQ_ID_VAL_LIST), TRUE),\r
- CIfrOpHeader (EFI_IFR_EQ_ID_VAL_LIST_OP, &mEqIdVList->Header) {\r
+ ) : CIfrObj (EFI_IFR_EQ_ID_VAL_LIST_OP, (CHAR8 **)NULL, sizeof (EFI_IFR_EQ_ID_VAL_LIST), TRUE),\r
+ CIfrOpHeader (EFI_IFR_EQ_ID_VAL_LIST_OP, &(GetObjBinAddr<EFI_IFR_EQ_ID_VAL_LIST>())->Header), mEqIdVList(GetObjBinAddr<EFI_IFR_EQ_ID_VAL_LIST>()) {\r
SetLineNo (LineNo);\r
mEqIdVList->QuestionId = EFI_QUESTION_ID_INVALID;\r
mEqIdVList->ListLength = 0;\r
VOID UpdateIfrBuffer ( \r
) {\r
_EMIT_PENDING_OBJ();\r
- mEqIdVList = (EFI_IFR_EQ_ID_VAL_LIST *) GetObjBinAddr();\r
+ mEqIdVList = GetObjBinAddr<EFI_IFR_EQ_ID_VAL_LIST>();\r
UpdateHeader (&mEqIdVList->Header);\r
}\r
\r
public:\r
CIfrQuestionRef1 (\r
IN UINT32 LineNo\r
- ) : CIfrObj (EFI_IFR_QUESTION_REF1_OP, (CHAR8 **)&mQuestionRef1),\r
- CIfrOpHeader (EFI_IFR_QUESTION_REF1_OP, &mQuestionRef1->Header) {\r
+ ) : CIfrObj (EFI_IFR_QUESTION_REF1_OP),\r
+ CIfrOpHeader (EFI_IFR_QUESTION_REF1_OP, &(GetObjBinAddr<EFI_IFR_QUESTION_REF1>())->Header), mQuestionRef1(GetObjBinAddr<EFI_IFR_QUESTION_REF1>()) {\r
SetLineNo (LineNo);\r
mQuestionRef1->QuestionId = EFI_QUESTION_ID_INVALID;\r
}\r
};\r
\r
class CIfrQuestionRef2 : public CIfrObj, public CIfrOpHeader {\r
-private:\r
- EFI_IFR_QUESTION_REF2 *mQuestionRef2;\r
-\r
public:\r
CIfrQuestionRef2 (\r
IN UINT32 LineNo\r
- ) : CIfrObj (EFI_IFR_QUESTION_REF2_OP, (CHAR8 **)&mQuestionRef2),\r
- CIfrOpHeader (EFI_IFR_QUESTION_REF2_OP, &mQuestionRef2->Header) {\r
+ ) : CIfrObj (EFI_IFR_QUESTION_REF2_OP),\r
+ CIfrOpHeader (EFI_IFR_QUESTION_REF2_OP, &(GetObjBinAddr<EFI_IFR_QUESTION_REF2>())->Header) {\r
SetLineNo (LineNo);\r
}\r
};\r
\r
class CIfrQuestionRef3 : public CIfrObj, public CIfrOpHeader {\r
-private:\r
- EFI_IFR_QUESTION_REF3 *mQuestionRef3;\r
-\r
public:\r
CIfrQuestionRef3 (\r
IN UINT32 LineNo\r
- ) : CIfrObj (EFI_IFR_QUESTION_REF3_OP, (CHAR8 **)&mQuestionRef3),\r
- CIfrOpHeader (EFI_IFR_QUESTION_REF3_OP, &mQuestionRef3->Header) {\r
+ ) : CIfrObj (EFI_IFR_QUESTION_REF3_OP),\r
+ CIfrOpHeader (EFI_IFR_QUESTION_REF3_OP, &(GetObjBinAddr<EFI_IFR_QUESTION_REF3>())->Header) {\r
SetLineNo (LineNo);\r
}\r
};\r
public:\r
CIfrQuestionRef3_2 (\r
IN UINT32 LineNo\r
- ) : CIfrObj (EFI_IFR_QUESTION_REF3_OP, (CHAR8 **)&mQuestionRef3_2, sizeof (EFI_IFR_QUESTION_REF3_2)),\r
- CIfrOpHeader (EFI_IFR_QUESTION_REF3_OP, &mQuestionRef3_2->Header, sizeof (EFI_IFR_QUESTION_REF3_2)) {\r
+ ) : CIfrObj (EFI_IFR_QUESTION_REF3_OP, (CHAR8 **)NULL, sizeof (EFI_IFR_QUESTION_REF3_2)),\r
+ CIfrOpHeader (EFI_IFR_QUESTION_REF3_OP, &(GetObjBinAddr<EFI_IFR_QUESTION_REF3_2>())->Header, sizeof (EFI_IFR_QUESTION_REF3_2)), mQuestionRef3_2(GetObjBinAddr<EFI_IFR_QUESTION_REF3_2>()) {\r
SetLineNo (LineNo);\r
mQuestionRef3_2->DevicePath = EFI_STRING_ID_INVALID;\r
}\r
public:\r
CIfrQuestionRef3_3 (\r
IN UINT32 LineNo\r
- ) : CIfrObj (EFI_IFR_QUESTION_REF3_OP, (CHAR8 **)&mQuestionRef3_3, sizeof (EFI_IFR_QUESTION_REF3_3)),\r
- CIfrOpHeader (EFI_IFR_QUESTION_REF3_OP, &mQuestionRef3_3->Header, sizeof (EFI_IFR_QUESTION_REF3_3)) {\r
+ ) : CIfrObj (EFI_IFR_QUESTION_REF3_OP, (CHAR8 **)NULL, sizeof (EFI_IFR_QUESTION_REF3_3)),\r
+ CIfrOpHeader (EFI_IFR_QUESTION_REF3_OP, &(GetObjBinAddr<EFI_IFR_QUESTION_REF3_3>())->Header, sizeof (EFI_IFR_QUESTION_REF3_3)), mQuestionRef3_3(GetObjBinAddr<EFI_IFR_QUESTION_REF3_3>()) {\r
SetLineNo (LineNo);\r
mQuestionRef3_3->DevicePath = EFI_STRING_ID_INVALID;\r
memset (&mQuestionRef3_3->Guid, 0, sizeof (EFI_GUID));\r
public:\r
CIfrRuleRef (\r
IN UINT32 LineNo\r
- ) : CIfrObj (EFI_IFR_RULE_REF_OP, (CHAR8 **)&mRuleRef),\r
- CIfrOpHeader (EFI_IFR_RULE_REF_OP, &mRuleRef->Header) {\r
+ ) : CIfrObj (EFI_IFR_RULE_REF_OP),\r
+ CIfrOpHeader (EFI_IFR_RULE_REF_OP, &(GetObjBinAddr<EFI_IFR_RULE_REF>())->Header), mRuleRef(GetObjBinAddr<EFI_IFR_RULE_REF>()) {\r
SetLineNo (LineNo);\r
mRuleRef->RuleId = EFI_RULE_ID_INVALID;\r
}\r
public:\r
CIfrStringRef1 (\r
IN UINT32 LineNo\r
- ) : CIfrObj (EFI_IFR_STRING_REF1_OP, (CHAR8 **)&mStringRef1),\r
- CIfrOpHeader (EFI_IFR_STRING_REF1_OP, &mStringRef1->Header) {\r
+ ) : CIfrObj (EFI_IFR_STRING_REF1_OP),\r
+ CIfrOpHeader (EFI_IFR_STRING_REF1_OP, &(GetObjBinAddr<EFI_IFR_STRING_REF1>())->Header), mStringRef1(GetObjBinAddr<EFI_IFR_STRING_REF1>()) {\r
SetLineNo (LineNo);\r
mStringRef1->StringId = EFI_STRING_ID_INVALID;\r
}\r
};\r
\r
class CIfrStringRef2 : public CIfrObj, public CIfrOpHeader {\r
-private:\r
- EFI_IFR_STRING_REF2 *mStringRef2;\r
-\r
public:\r
CIfrStringRef2 (\r
IN UINT32 LineNo\r
- ) : CIfrObj (EFI_IFR_STRING_REF2_OP, (CHAR8 **)&mStringRef2),\r
- CIfrOpHeader (EFI_IFR_STRING_REF2_OP, &mStringRef2->Header) {\r
+ ) : CIfrObj (EFI_IFR_STRING_REF2_OP),\r
+ CIfrOpHeader (EFI_IFR_STRING_REF2_OP, &(GetObjBinAddr<EFI_IFR_STRING_REF2>())->Header) {\r
SetLineNo (LineNo);\r
}\r
};\r
\r
class CIfrThis : public CIfrObj, public CIfrOpHeader {\r
-private:\r
- EFI_IFR_THIS *mThis;\r
-\r
public:\r
CIfrThis (\r
IN UINT32 LineNo\r
- ) : CIfrObj (EFI_IFR_THIS_OP, (CHAR8 **)&mThis),\r
- CIfrOpHeader (EFI_IFR_THIS_OP, &mThis->Header) {\r
+ ) : CIfrObj (EFI_IFR_THIS_OP),\r
+ CIfrOpHeader (EFI_IFR_THIS_OP, &(GetObjBinAddr<EFI_IFR_THIS>())->Header) {\r
SetLineNo (LineNo);\r
}\r
};\r
public:\r
CIfrSecurity (\r
IN UINT32 LineNo\r
- ) : CIfrObj (EFI_IFR_SECURITY_OP, (CHAR8 **)&mSecurity),\r
- CIfrOpHeader (EFI_IFR_SECURITY_OP, &mSecurity->Header) {\r
+ ) : CIfrObj (EFI_IFR_SECURITY_OP),\r
+ CIfrOpHeader (EFI_IFR_SECURITY_OP, &(GetObjBinAddr<EFI_IFR_SECURITY>())->Header), mSecurity(GetObjBinAddr<EFI_IFR_SECURITY>()) {\r
SetLineNo (LineNo);\r
memset (&mSecurity->Permissions, 0, sizeof (EFI_GUID));\r
}\r
public:\r
CIfrUint8 (\r
IN UINT32 LineNo\r
- ) : CIfrObj (EFI_IFR_UINT8_OP, (CHAR8 **)&mUint8),\r
- CIfrOpHeader (EFI_IFR_UINT8_OP, &mUint8->Header) {\r
+ ) : CIfrObj (EFI_IFR_UINT8_OP),\r
+ CIfrOpHeader (EFI_IFR_UINT8_OP, &(GetObjBinAddr<EFI_IFR_UINT8>())->Header), mUint8(GetObjBinAddr<EFI_IFR_UINT8>()) {\r
SetLineNo (LineNo);\r
}\r
\r
public:\r
CIfrUint16 (\r
IN UINT32 LineNo\r
- ) : CIfrObj (EFI_IFR_UINT16_OP, (CHAR8 **)&mUint16),\r
- CIfrOpHeader (EFI_IFR_UINT16_OP, &mUint16->Header) {\r
+ ) : CIfrObj (EFI_IFR_UINT16_OP),\r
+ CIfrOpHeader (EFI_IFR_UINT16_OP, &(GetObjBinAddr<EFI_IFR_UINT16>())->Header), mUint16(GetObjBinAddr<EFI_IFR_UINT16>()) {\r
SetLineNo (LineNo);\r
}\r
\r
public:\r
CIfrUint32 (\r
IN UINT32 LineNo\r
- ) : CIfrObj (EFI_IFR_UINT32_OP, (CHAR8 **)&mUint32),\r
- CIfrOpHeader (EFI_IFR_UINT32_OP, &mUint32->Header) {\r
+ ) : CIfrObj (EFI_IFR_UINT32_OP),\r
+ CIfrOpHeader (EFI_IFR_UINT32_OP, &(GetObjBinAddr<EFI_IFR_UINT32>())->Header), mUint32(GetObjBinAddr<EFI_IFR_UINT32>()) {\r
SetLineNo (LineNo);\r
}\r
\r
public:\r
CIfrUint64 (\r
IN UINT32 LineNo\r
- ) : CIfrObj (EFI_IFR_UINT64_OP, (CHAR8 **)&mUint64),\r
- CIfrOpHeader (EFI_IFR_UINT64_OP, &mUint64->Header) {\r
+ ) : CIfrObj (EFI_IFR_UINT64_OP),\r
+ CIfrOpHeader (EFI_IFR_UINT64_OP, &(GetObjBinAddr<EFI_IFR_UINT64>())->Header), mUint64(GetObjBinAddr<EFI_IFR_UINT64>()) {\r
SetLineNo (LineNo);\r
}\r
\r
};\r
\r
class CIfrTrue : public CIfrObj, public CIfrOpHeader {\r
-private:\r
- EFI_IFR_TRUE *mTrue;\r
-\r
public:\r
CIfrTrue (\r
IN UINT32 LineNo\r
- ) : CIfrObj (EFI_IFR_TRUE_OP, (CHAR8 **)&mTrue),\r
- CIfrOpHeader (EFI_IFR_TRUE_OP, &mTrue->Header) {\r
+ ) : CIfrObj (EFI_IFR_TRUE_OP),\r
+ CIfrOpHeader (EFI_IFR_TRUE_OP, &(GetObjBinAddr<EFI_IFR_TRUE>())->Header) {\r
SetLineNo (LineNo);\r
}\r
};\r
\r
class CIfrFalse : public CIfrObj, public CIfrOpHeader {\r
-private:\r
- EFI_IFR_FALSE *mFalse;\r
-\r
public:\r
CIfrFalse (\r
IN UINT32 LineNo\r
- ) : CIfrObj (EFI_IFR_FALSE_OP, (CHAR8 **)&mFalse),\r
- CIfrOpHeader (EFI_IFR_FALSE_OP, &mFalse->Header) {\r
+ ) : CIfrObj (EFI_IFR_FALSE_OP),\r
+ CIfrOpHeader (EFI_IFR_FALSE_OP, &(GetObjBinAddr<EFI_IFR_FALSE>())->Header) {\r
SetLineNo (LineNo);\r
}\r
};\r
\r
class CIfrOne : public CIfrObj, public CIfrOpHeader {\r
-private:\r
- EFI_IFR_ONE *mOne;\r
-\r
public:\r
CIfrOne (\r
IN UINT32 LineNo\r
- ) : CIfrObj (EFI_IFR_ONE_OP, (CHAR8 **)&mOne),\r
- CIfrOpHeader (EFI_IFR_ONE_OP, &mOne->Header) {\r
+ ) : CIfrObj (EFI_IFR_ONE_OP),\r
+ CIfrOpHeader (EFI_IFR_ONE_OP, &(GetObjBinAddr<EFI_IFR_ONE>())->Header) {\r
SetLineNo (LineNo);\r
}\r
};\r
\r
class CIfrOnes : public CIfrObj, public CIfrOpHeader {\r
-private:\r
- EFI_IFR_ONES *mOnes;\r
-\r
public:\r
CIfrOnes (\r
IN UINT32 LineNo\r
- ) : CIfrObj (EFI_IFR_ONES_OP, (CHAR8 **)&mOnes),\r
- CIfrOpHeader (EFI_IFR_ONES_OP, &mOnes->Header) {\r
+ ) : CIfrObj (EFI_IFR_ONES_OP),\r
+ CIfrOpHeader (EFI_IFR_ONES_OP, &(GetObjBinAddr<EFI_IFR_ONES>())->Header) {\r
SetLineNo (LineNo);\r
}\r
};\r
\r
class CIfrZero : public CIfrObj, public CIfrOpHeader {\r
-private:\r
- EFI_IFR_ZERO *mZero;\r
-\r
public:\r
CIfrZero (\r
IN UINT32 LineNo\r
- ) : CIfrObj (EFI_IFR_ZERO_OP, (CHAR8 **)&mZero),\r
- CIfrOpHeader (EFI_IFR_ZERO_OP, &mZero->Header) {\r
+ ) : CIfrObj (EFI_IFR_ZERO_OP),\r
+ CIfrOpHeader (EFI_IFR_ZERO_OP, &(GetObjBinAddr<EFI_IFR_ZERO>())->Header) {\r
SetLineNo (LineNo);\r
}\r
};\r
\r
class CIfrUndefined : public CIfrObj, public CIfrOpHeader {\r
-private:\r
- EFI_IFR_UNDEFINED *mUndefined;\r
-\r
public:\r
CIfrUndefined (\r
IN UINT32 LineNo\r
- ) : CIfrObj (EFI_IFR_UNDEFINED_OP, (CHAR8 **)&mUndefined),\r
- CIfrOpHeader (EFI_IFR_UNDEFINED_OP, &mUndefined->Header) {\r
+ ) : CIfrObj (EFI_IFR_UNDEFINED_OP),\r
+ CIfrOpHeader (EFI_IFR_UNDEFINED_OP, &(GetObjBinAddr<EFI_IFR_UNDEFINED>())->Header) {\r
SetLineNo (LineNo);\r
}\r
};\r
\r
class CIfrVersion : public CIfrObj, public CIfrOpHeader {\r
-private:\r
- EFI_IFR_VERSION *mVersion;\r
-\r
public:\r
CIfrVersion (\r
IN UINT32 LineNo\r
- ) : CIfrObj (EFI_IFR_VERSION_OP, (CHAR8 **)&mVersion),\r
- CIfrOpHeader (EFI_IFR_VERSION_OP, &mVersion->Header) {\r
+ ) : CIfrObj (EFI_IFR_VERSION_OP),\r
+ CIfrOpHeader (EFI_IFR_VERSION_OP, &(GetObjBinAddr<EFI_IFR_VERSION>())->Header) {\r
SetLineNo (LineNo);\r
}\r
};\r
\r
class CIfrLength : public CIfrObj, public CIfrOpHeader {\r
-private:\r
- EFI_IFR_LENGTH *mLength;\r
-\r
public:\r
CIfrLength (\r
IN UINT32 LineNo\r
- ) : CIfrObj (EFI_IFR_LENGTH_OP, (CHAR8 **)&mLength),\r
- CIfrOpHeader (EFI_IFR_LENGTH_OP, &mLength->Header) {\r
+ ) : CIfrObj (EFI_IFR_LENGTH_OP),\r
+ CIfrOpHeader (EFI_IFR_LENGTH_OP, &(GetObjBinAddr<EFI_IFR_LENGTH>())->Header) {\r
SetLineNo (LineNo);\r
}\r
};\r
\r
class CIfrNot : public CIfrObj, public CIfrOpHeader {\r
-private:\r
- EFI_IFR_NOT *mNot;\r
-\r
public:\r
CIfrNot (\r
IN UINT32 LineNo\r
- ) : CIfrObj (EFI_IFR_NOT_OP, (CHAR8 **)&mNot),\r
- CIfrOpHeader (EFI_IFR_NOT_OP, &mNot->Header) {\r
+ ) : CIfrObj (EFI_IFR_NOT_OP),\r
+ CIfrOpHeader (EFI_IFR_NOT_OP, &(GetObjBinAddr<EFI_IFR_NOT>())->Header) {\r
SetLineNo (LineNo);\r
}\r
};\r
\r
class CIfrBitWiseNot : public CIfrObj, public CIfrOpHeader {\r
-private:\r
- EFI_IFR_BITWISE_NOT *mBitWise;\r
-\r
public:\r
CIfrBitWiseNot (\r
IN UINT32 LineNo\r
- ) : CIfrObj (EFI_IFR_BITWISE_NOT_OP, (CHAR8 **)&mBitWise),\r
- CIfrOpHeader (EFI_IFR_BITWISE_NOT_OP, &mBitWise->Header) {\r
+ ) : CIfrObj (EFI_IFR_BITWISE_NOT_OP),\r
+ CIfrOpHeader (EFI_IFR_BITWISE_NOT_OP, &(GetObjBinAddr<EFI_IFR_BITWISE_NOT>())->Header) {\r
SetLineNo (LineNo);\r
}\r
};\r
\r
class CIfrToBoolean : public CIfrObj, public CIfrOpHeader {\r
-private:\r
- EFI_IFR_TO_BOOLEAN *mToBoolean;\r
-\r
public:\r
CIfrToBoolean (\r
IN UINT32 LineNo\r
- ) : CIfrObj (EFI_IFR_TO_BOOLEAN_OP, (CHAR8 **)&mToBoolean),\r
- CIfrOpHeader (EFI_IFR_TO_BOOLEAN_OP, &mToBoolean->Header) {\r
+ ) : CIfrObj (EFI_IFR_TO_BOOLEAN_OP),\r
+ CIfrOpHeader (EFI_IFR_TO_BOOLEAN_OP, &(GetObjBinAddr<EFI_IFR_TO_BOOLEAN>())->Header) {\r
SetLineNo (LineNo);\r
}\r
};\r
public:\r
CIfrToString (\r
IN UINT32 LineNo\r
- ) : CIfrObj (EFI_IFR_TO_STRING_OP, (CHAR8 **)&mToString),\r
- CIfrOpHeader (EFI_IFR_TO_STRING_OP, &mToString->Header) {\r
+ ) : CIfrObj (EFI_IFR_TO_STRING_OP),\r
+ CIfrOpHeader (EFI_IFR_TO_STRING_OP, &(GetObjBinAddr<EFI_IFR_TO_STRING>())->Header), mToString(GetObjBinAddr<EFI_IFR_TO_STRING>()) {\r
SetLineNo (LineNo);\r
}\r
\r
};\r
\r
class CIfrToUint : public CIfrObj, public CIfrOpHeader {\r
-private:\r
- EFI_IFR_TO_UINT *mToUint;\r
-\r
public:\r
CIfrToUint (\r
IN UINT32 LineNo\r
- ) : CIfrObj (EFI_IFR_TO_UINT_OP, (CHAR8 **)&mToUint),\r
- CIfrOpHeader (EFI_IFR_TO_UINT_OP, &mToUint->Header) {\r
+ ) : CIfrObj (EFI_IFR_TO_UINT_OP),\r
+ CIfrOpHeader (EFI_IFR_TO_UINT_OP, &(GetObjBinAddr<EFI_IFR_TO_UINT>())->Header) {\r
SetLineNo (LineNo);\r
}\r
};\r
\r
class CIfrToUpper : public CIfrObj, public CIfrOpHeader {\r
-private:\r
- EFI_IFR_TO_UPPER *mToUpper;\r
-\r
public:\r
CIfrToUpper (\r
IN UINT32 LineNo\r
- ) : CIfrObj (EFI_IFR_TO_UPPER_OP, (CHAR8 **)&mToUpper),\r
- CIfrOpHeader (EFI_IFR_TO_UPPER_OP, &mToUpper->Header) {\r
+ ) : CIfrObj (EFI_IFR_TO_UPPER_OP),\r
+ CIfrOpHeader (EFI_IFR_TO_UPPER_OP, &(GetObjBinAddr<EFI_IFR_TO_UPPER>())->Header) {\r
SetLineNo (LineNo);\r
}\r
};\r
\r
class CIfrToLower : public CIfrObj, public CIfrOpHeader {\r
-private:\r
- EFI_IFR_TO_LOWER *mToLower;\r
-\r
public:\r
CIfrToLower (\r
IN UINT32 LineNo\r
- ) : CIfrObj (EFI_IFR_TO_LOWER_OP, (CHAR8 **)&mToLower),\r
- CIfrOpHeader (EFI_IFR_TO_LOWER_OP, &mToLower->Header) {\r
+ ) : CIfrObj (EFI_IFR_TO_LOWER_OP),\r
+ CIfrOpHeader (EFI_IFR_TO_LOWER_OP, &(GetObjBinAddr<EFI_IFR_TO_LOWER>())->Header) {\r
SetLineNo (LineNo);\r
}\r
};\r
\r
class CIfrAdd : public CIfrObj, public CIfrOpHeader {\r
-private:\r
- EFI_IFR_ADD *mAdd;\r
-\r
public:\r
CIfrAdd (\r
IN UINT32 LineNo\r
- ) : CIfrObj (EFI_IFR_ADD_OP, (CHAR8 **)&mAdd),\r
- CIfrOpHeader (EFI_IFR_ADD_OP, &mAdd->Header) {\r
+ ) : CIfrObj (EFI_IFR_ADD_OP),\r
+ CIfrOpHeader (EFI_IFR_ADD_OP, &(GetObjBinAddr<EFI_IFR_ADD>())->Header) {\r
SetLineNo (LineNo);\r
}\r
};\r
\r
class CIfrBitWiseAnd : public CIfrObj, public CIfrOpHeader {\r
-private:\r
- EFI_IFR_BITWISE_AND *mBitWiseAnd;\r
-\r
public:\r
CIfrBitWiseAnd (\r
IN UINT32 LineNo\r
- ) : CIfrObj (EFI_IFR_BITWISE_AND_OP, (CHAR8 **)&mBitWiseAnd),\r
- CIfrOpHeader (EFI_IFR_BITWISE_AND_OP, &mBitWiseAnd->Header) {\r
+ ) : CIfrObj (EFI_IFR_BITWISE_AND_OP),\r
+ CIfrOpHeader (EFI_IFR_BITWISE_AND_OP, &(GetObjBinAddr<EFI_IFR_BITWISE_AND>())->Header) {\r
SetLineNo(LineNo);\r
}\r
};\r
\r
class CIfrBitWiseOr : public CIfrObj, public CIfrOpHeader {\r
-private:\r
- EFI_IFR_BITWISE_OR *mBitWiseOr;\r
-\r
public:\r
CIfrBitWiseOr (\r
IN UINT32 LineNo\r
- ) : CIfrObj (EFI_IFR_BITWISE_OR_OP, (CHAR8 **)&mBitWiseOr),\r
- CIfrOpHeader (EFI_IFR_BITWISE_OR_OP, &mBitWiseOr->Header) {\r
+ ) : CIfrObj (EFI_IFR_BITWISE_OR_OP),\r
+ CIfrOpHeader (EFI_IFR_BITWISE_OR_OP, &(GetObjBinAddr<EFI_IFR_BITWISE_OR>())->Header) {\r
SetLineNo (LineNo);\r
}\r
};\r
\r
class CIfrAnd : public CIfrObj, public CIfrOpHeader {\r
-private:\r
- EFI_IFR_AND *mAnd;\r
-\r
public:\r
CIfrAnd (\r
IN UINT32 LineNo\r
- ) : CIfrObj (EFI_IFR_AND_OP, (CHAR8 **)&mAnd),\r
- CIfrOpHeader (EFI_IFR_AND_OP, &mAnd->Header) {\r
+ ) : CIfrObj (EFI_IFR_AND_OP),\r
+ CIfrOpHeader (EFI_IFR_AND_OP, &(GetObjBinAddr<EFI_IFR_AND>())->Header) {\r
SetLineNo (LineNo);\r
}\r
};\r
\r
class CIfrCatenate : public CIfrObj, public CIfrOpHeader {\r
-private:\r
- EFI_IFR_CATENATE *mCatenate;\r
-\r
public:\r
CIfrCatenate (\r
IN UINT32 LineNo\r
- ) : CIfrObj (EFI_IFR_CATENATE_OP, (CHAR8 **)&mCatenate),\r
- CIfrOpHeader (EFI_IFR_CATENATE_OP, &mCatenate->Header) {\r
+ ) : CIfrObj (EFI_IFR_CATENATE_OP),\r
+ CIfrOpHeader (EFI_IFR_CATENATE_OP, &(GetObjBinAddr<EFI_IFR_CATENATE>())->Header) {\r
SetLineNo (LineNo);\r
}\r
};\r
\r
class CIfrDivide : public CIfrObj, public CIfrOpHeader {\r
-private:\r
- EFI_IFR_DIVIDE *mDivide;\r
-\r
public:\r
CIfrDivide (\r
IN UINT32 LineNo\r
- ) : CIfrObj (EFI_IFR_DIVIDE_OP, (CHAR8 **)&mDivide),\r
- CIfrOpHeader (EFI_IFR_DIVIDE_OP, &mDivide->Header) {\r
+ ) : CIfrObj (EFI_IFR_DIVIDE_OP),\r
+ CIfrOpHeader (EFI_IFR_DIVIDE_OP, &(GetObjBinAddr<EFI_IFR_DIVIDE>())->Header) {\r
SetLineNo (LineNo);\r
}\r
};\r
\r
class CIfrEqual : public CIfrObj, public CIfrOpHeader {\r
-private:\r
- EFI_IFR_EQUAL *mEqual;\r
-\r
public:\r
CIfrEqual (\r
IN UINT32 LineNo\r
- ) : CIfrObj (EFI_IFR_EQUAL_OP, (CHAR8 **)&mEqual),\r
- CIfrOpHeader (EFI_IFR_EQUAL_OP, &mEqual->Header) {\r
+ ) : CIfrObj (EFI_IFR_EQUAL_OP),\r
+ CIfrOpHeader (EFI_IFR_EQUAL_OP, &(GetObjBinAddr<EFI_IFR_EQUAL>())->Header) {\r
SetLineNo (LineNo);\r
}\r
};\r
\r
class CIfrGreaterEqual : public CIfrObj, public CIfrOpHeader {\r
-private:\r
- EFI_IFR_GREATER_EQUAL *mGreaterEqual;\r
-\r
public:\r
CIfrGreaterEqual (\r
IN UINT32 LineNo\r
- ) : CIfrObj (EFI_IFR_GREATER_EQUAL_OP, (CHAR8 **)&mGreaterEqual),\r
- CIfrOpHeader (EFI_IFR_GREATER_EQUAL_OP, &mGreaterEqual->Header) {\r
+ ) : CIfrObj (EFI_IFR_GREATER_EQUAL_OP),\r
+ CIfrOpHeader (EFI_IFR_GREATER_EQUAL_OP, &(GetObjBinAddr<EFI_IFR_GREATER_EQUAL>())->Header) {\r
SetLineNo (LineNo);\r
}\r
};\r
\r
class CIfrGreaterThan : public CIfrObj, public CIfrOpHeader {\r
-private:\r
- EFI_IFR_GREATER_THAN *mGreaterThan;\r
-\r
public:\r
CIfrGreaterThan (\r
IN UINT32 LineNo\r
- ) : CIfrObj (EFI_IFR_GREATER_THAN_OP, (CHAR8 **)&mGreaterThan),\r
- CIfrOpHeader (EFI_IFR_GREATER_THAN_OP, &mGreaterThan->Header) {\r
+ ) : CIfrObj (EFI_IFR_GREATER_THAN_OP),\r
+ CIfrOpHeader (EFI_IFR_GREATER_THAN_OP, &(GetObjBinAddr<EFI_IFR_GREATER_THAN>())->Header) {\r
SetLineNo (LineNo);\r
}\r
};\r
\r
class CIfrLessEqual : public CIfrObj, public CIfrOpHeader {\r
-private:\r
- EFI_IFR_LESS_EQUAL *mLessEqual;\r
-\r
public:\r
CIfrLessEqual (\r
IN UINT32 LineNo\r
- ) : CIfrObj (EFI_IFR_LESS_EQUAL_OP, (CHAR8 **)&mLessEqual),\r
- CIfrOpHeader (EFI_IFR_LESS_EQUAL_OP, &mLessEqual->Header) {\r
+ ) : CIfrObj (EFI_IFR_LESS_EQUAL_OP),\r
+ CIfrOpHeader (EFI_IFR_LESS_EQUAL_OP, &(GetObjBinAddr<EFI_IFR_LESS_EQUAL>())->Header) {\r
SetLineNo (LineNo);\r
}\r
};\r
\r
class CIfrLessThan : public CIfrObj, public CIfrOpHeader {\r
-private:\r
- EFI_IFR_LESS_THAN *mLessThan;\r
-\r
public:\r
CIfrLessThan (\r
IN UINT32 LineNo\r
- ) : CIfrObj (EFI_IFR_LESS_THAN_OP, (CHAR8 **)&mLessThan),\r
- CIfrOpHeader (EFI_IFR_LESS_THAN_OP, &mLessThan->Header) {\r
+ ) : CIfrObj (EFI_IFR_LESS_THAN_OP),\r
+ CIfrOpHeader (EFI_IFR_LESS_THAN_OP, &(GetObjBinAddr<EFI_IFR_LESS_THAN>())->Header) {\r
SetLineNo (LineNo);\r
}\r
};\r
\r
class CIfrMap : public CIfrObj, public CIfrOpHeader{\r
-private:\r
- EFI_IFR_MAP *mMap;\r
-\r
public:\r
CIfrMap (\r
IN UINT32 LineNo \r
- ) : CIfrObj (EFI_IFR_MAP_OP, (CHAR8 **)&mMap),\r
- CIfrOpHeader (EFI_IFR_MAP_OP, &mMap->Header) {\r
+ ) : CIfrObj (EFI_IFR_MAP_OP),\r
+ CIfrOpHeader (EFI_IFR_MAP_OP, &(GetObjBinAddr<EFI_IFR_MAP>())->Header) {\r
SetLineNo (LineNo);\r
}\r
};\r
\r
class CIfrMatch : public CIfrObj, public CIfrOpHeader {\r
-private:\r
- EFI_IFR_MATCH *mMatch;\r
-\r
public:\r
CIfrMatch (\r
IN UINT32 LineNo\r
- ) : CIfrObj (EFI_IFR_MATCH_OP, (CHAR8 **)&mMatch),\r
- CIfrOpHeader (EFI_IFR_MATCH_OP, &mMatch->Header) {\r
+ ) : CIfrObj (EFI_IFR_MATCH_OP),\r
+ CIfrOpHeader (EFI_IFR_MATCH_OP, &(GetObjBinAddr<EFI_IFR_MATCH>())->Header) {\r
SetLineNo (LineNo);\r
}\r
};\r
\r
-class CIfrMultiply : public CIfrObj, public CIfrOpHeader {\r
+class CIfrMatch2 : public CIfrObj, public CIfrOpHeader {\r
private:\r
- EFI_IFR_MULTIPLY *mMultiply;\r
+ EFI_IFR_MATCH2 *mMatch2;\r
+\r
+public:\r
+ CIfrMatch2 (\r
+ IN UINT32 LineNo,\r
+ IN EFI_GUID *Guid\r
+ ) : CIfrObj (EFI_IFR_MATCH2_OP),\r
+ CIfrOpHeader (EFI_IFR_MATCH2_OP, &(GetObjBinAddr<EFI_IFR_MATCH2>())->Header), mMatch2(GetObjBinAddr<EFI_IFR_MATCH2>()) {\r
+ SetLineNo (LineNo);\r
+ memmove (&mMatch2->SyntaxType, Guid, sizeof (EFI_GUID));\r
+ }\r
+};\r
\r
+class CIfrMultiply : public CIfrObj, public CIfrOpHeader {\r
public:\r
CIfrMultiply (\r
IN UINT32 LineNo\r
- ) : CIfrObj (EFI_IFR_MULTIPLY_OP, (CHAR8 **)&mMultiply),\r
- CIfrOpHeader (EFI_IFR_MULTIPLY_OP, &mMultiply->Header) {\r
+ ) : CIfrObj (EFI_IFR_MULTIPLY_OP),\r
+ CIfrOpHeader (EFI_IFR_MULTIPLY_OP, &(GetObjBinAddr<EFI_IFR_MULTIPLY>())->Header) {\r
SetLineNo (LineNo);\r
}\r
};\r
\r
class CIfrModulo : public CIfrObj, public CIfrOpHeader {\r
-private:\r
- EFI_IFR_MODULO *mModulo;\r
-\r
public:\r
CIfrModulo (\r
IN UINT32 LineNo\r
- ) : CIfrObj (EFI_IFR_MODULO_OP, (CHAR8 **)&mModulo),\r
- CIfrOpHeader (EFI_IFR_MODULO_OP, &mModulo->Header) {\r
+ ) : CIfrObj (EFI_IFR_MODULO_OP),\r
+ CIfrOpHeader (EFI_IFR_MODULO_OP, &(GetObjBinAddr<EFI_IFR_MODULO>())->Header) {\r
SetLineNo (LineNo);\r
}\r
};\r
\r
class CIfrNotEqual : public CIfrObj, public CIfrOpHeader {\r
-private:\r
- EFI_IFR_NOT_EQUAL *mNotEqual;\r
-\r
public:\r
CIfrNotEqual (\r
IN UINT32 LineNo\r
- ) : CIfrObj (EFI_IFR_NOT_EQUAL_OP, (CHAR8 **)&mNotEqual),\r
- CIfrOpHeader (EFI_IFR_NOT_EQUAL_OP, &mNotEqual->Header) {\r
+ ) : CIfrObj (EFI_IFR_NOT_EQUAL_OP),\r
+ CIfrOpHeader (EFI_IFR_NOT_EQUAL_OP, &(GetObjBinAddr<EFI_IFR_NOT_EQUAL>())->Header) {\r
SetLineNo (LineNo);\r
}\r
};\r
\r
class CIfrOr : public CIfrObj, public CIfrOpHeader {\r
-private:\r
- EFI_IFR_OR *mOr;\r
-\r
public:\r
CIfrOr (\r
IN UINT32 LineNo\r
- ) : CIfrObj (EFI_IFR_OR_OP, (CHAR8 **)&mOr),\r
- CIfrOpHeader (EFI_IFR_OR_OP, &mOr->Header) {\r
+ ) : CIfrObj (EFI_IFR_OR_OP),\r
+ CIfrOpHeader (EFI_IFR_OR_OP, &(GetObjBinAddr<EFI_IFR_OR>())->Header) {\r
SetLineNo (LineNo);\r
}\r
};\r
\r
class CIfrShiftLeft : public CIfrObj, public CIfrOpHeader {\r
-private:\r
- EFI_IFR_SHIFT_LEFT *mShiftLeft;\r
-\r
public:\r
CIfrShiftLeft (\r
IN UINT32 LineNo\r
- ) : CIfrObj (EFI_IFR_SHIFT_LEFT_OP, (CHAR8 **)&mShiftLeft),\r
- CIfrOpHeader (EFI_IFR_SHIFT_LEFT_OP, &mShiftLeft->Header) {\r
+ ) : CIfrObj (EFI_IFR_SHIFT_LEFT_OP),\r
+ CIfrOpHeader (EFI_IFR_SHIFT_LEFT_OP, &(GetObjBinAddr<EFI_IFR_SHIFT_LEFT>())->Header) {\r
SetLineNo (LineNo);\r
}\r
};\r
\r
class CIfrShiftRight : public CIfrObj, public CIfrOpHeader {\r
-private:\r
- EFI_IFR_SHIFT_RIGHT *mShiftRight;\r
-\r
public:\r
CIfrShiftRight (\r
IN UINT32 LineNo\r
- ) : CIfrObj (EFI_IFR_SHIFT_RIGHT_OP, (CHAR8 **)&mShiftRight),\r
- CIfrOpHeader (EFI_IFR_SHIFT_RIGHT_OP, &mShiftRight->Header) {\r
+ ) : CIfrObj (EFI_IFR_SHIFT_RIGHT_OP),\r
+ CIfrOpHeader (EFI_IFR_SHIFT_RIGHT_OP, &(GetObjBinAddr<EFI_IFR_SHIFT_RIGHT>())->Header) {\r
SetLineNo (LineNo);\r
}\r
};\r
\r
class CIfrSubtract : public CIfrObj, public CIfrOpHeader {\r
-private:\r
- EFI_IFR_SUBTRACT *mSubtract;\r
-\r
public:\r
CIfrSubtract (\r
IN UINT32 LineNo\r
- ) : CIfrObj (EFI_IFR_SUBTRACT_OP, (CHAR8 **)&mSubtract),\r
- CIfrOpHeader (EFI_IFR_SUBTRACT_OP, &mSubtract->Header) {\r
+ ) : CIfrObj (EFI_IFR_SUBTRACT_OP),\r
+ CIfrOpHeader (EFI_IFR_SUBTRACT_OP, &(GetObjBinAddr<EFI_IFR_SUBTRACT>())->Header) {\r
SetLineNo (LineNo);\r
}\r
};\r
\r
class CIfrConditional : public CIfrObj, public CIfrOpHeader {\r
-private:\r
- EFI_IFR_CONDITIONAL *mConditional;\r
-\r
public:\r
CIfrConditional (\r
IN UINT32 LineNo\r
- ) : CIfrObj (EFI_IFR_CONDITIONAL_OP, (CHAR8 **)&mConditional),\r
- CIfrOpHeader (EFI_IFR_CONDITIONAL_OP, &mConditional->Header) {\r
+ ) : CIfrObj (EFI_IFR_CONDITIONAL_OP),\r
+ CIfrOpHeader (EFI_IFR_CONDITIONAL_OP, &(GetObjBinAddr<EFI_IFR_CONDITIONAL>())->Header) {\r
SetLineNo (LineNo);\r
}\r
};\r
public:\r
CIfrFind (\r
IN UINT32 LineNo\r
- ) : CIfrObj (EFI_IFR_FIND_OP, (CHAR8 **)&mFind),\r
- CIfrOpHeader (EFI_IFR_FIND_OP, &mFind->Header) {\r
+ ) : CIfrObj (EFI_IFR_FIND_OP),\r
+ CIfrOpHeader (EFI_IFR_FIND_OP, &(GetObjBinAddr<EFI_IFR_FIND>())->Header), mFind(GetObjBinAddr<EFI_IFR_FIND>()) {\r
SetLineNo (LineNo);\r
}\r
\r
};\r
\r
class CIfrMid : public CIfrObj, public CIfrOpHeader {\r
-private:\r
- EFI_IFR_MID *mMid;\r
-\r
public:\r
CIfrMid (\r
IN UINT32 LineNo\r
- ) : CIfrObj (EFI_IFR_MID_OP, (CHAR8 **)&mMid),\r
- CIfrOpHeader (EFI_IFR_MID_OP, &mMid->Header) {\r
+ ) : CIfrObj (EFI_IFR_MID_OP),\r
+ CIfrOpHeader (EFI_IFR_MID_OP, &(GetObjBinAddr<EFI_IFR_MID>())->Header) {\r
SetLineNo (LineNo);\r
}\r
};\r
\r
class CIfrToken : public CIfrObj, public CIfrOpHeader {\r
-private:\r
- EFI_IFR_TOKEN *mToken;\r
-\r
public:\r
CIfrToken (\r
IN UINT32 LineNo\r
- ) : CIfrObj (EFI_IFR_TOKEN_OP, (CHAR8 **)&mToken),\r
- CIfrOpHeader (EFI_IFR_TOKEN_OP, &mToken->Header) {\r
+ ) : CIfrObj (EFI_IFR_TOKEN_OP),\r
+ CIfrOpHeader (EFI_IFR_TOKEN_OP, &(GetObjBinAddr<EFI_IFR_TOKEN>())->Header) {\r
SetLineNo (LineNo);\r
}\r
};\r
public:\r
CIfrSpan (\r
IN UINT32 LineNo\r
- ) : CIfrObj (EFI_IFR_SPAN_OP, (CHAR8 **)&mSpan),\r
- CIfrOpHeader (EFI_IFR_SPAN_OP, &mSpan->Header) {\r
+ ) : CIfrObj (EFI_IFR_SPAN_OP),\r
+ CIfrOpHeader (EFI_IFR_SPAN_OP, &(GetObjBinAddr<EFI_IFR_SPAN>())->Header), mSpan(GetObjBinAddr<EFI_IFR_SPAN>()) {\r
SetLineNo (LineNo);\r
mSpan->Flags = EFI_IFR_FLAGS_FIRST_MATCHING;\r
}\r
projects / mirror_edk2.git / blobdiff