From mboxrd@z Thu Jan 1 00:00:00 1970 Return-Path: Received-SPF: Permerror (SPF Permanent Error: More than 10 MX records returned) identity=mailfrom; client-ip=192.55.52.136; helo=mga12.intel.com; envelope-from=liming.gao@intel.com; receiver=edk2-devel@lists.01.org Received: from mga12.intel.com (mga12.intel.com [192.55.52.136]) (using TLSv1.2 with cipher ECDHE-RSA-AES256-GCM-SHA384 (256/256 bits)) (No client certificate requested) by ml01.01.org (Postfix) with ESMTPS id CFD1820356262 for ; Sun, 10 Dec 2017 05:47:44 -0800 (PST) X-Amp-Result: SKIPPED(no attachment in message) X-Amp-File-Uploaded: False Received: from orsmga001.jf.intel.com ([10.7.209.18]) by fmsmga106.fm.intel.com with ESMTP/TLS/DHE-RSA-AES256-GCM-SHA384; 10 Dec 2017 05:52:20 -0800 X-ExtLoop1: 1 X-IronPort-AV: E=Sophos;i="5.45,388,1508828400"; d="scan'208";a="14781494" Received: from fmsmsx104.amr.corp.intel.com ([10.18.124.202]) by orsmga001.jf.intel.com with ESMTP; 10 Dec 2017 05:52:19 -0800 Received: from fmsmsx156.amr.corp.intel.com (10.18.116.74) by fmsmsx104.amr.corp.intel.com (10.18.124.202) with Microsoft SMTP Server (TLS) id 14.3.319.2; Sun, 10 Dec 2017 05:52:19 -0800 Received: from shsmsx103.ccr.corp.intel.com (10.239.4.69) by fmsmsx156.amr.corp.intel.com (10.18.116.74) with Microsoft SMTP Server (TLS) id 14.3.319.2; Sun, 10 Dec 2017 05:52:18 -0800 Received: from shsmsx104.ccr.corp.intel.com ([169.254.5.152]) by SHSMSX103.ccr.corp.intel.com ([169.254.4.213]) with mapi id 14.03.0319.002; Sun, 10 Dec 2017 21:52:16 +0800 From: "Gao, Liming" To: Zenith432 , "edk2-devel@lists.01.org" Thread-Topic: [edk2] [PATCH 4/4] BaseTools: resolve initialization order errors in VfrFormPkg.h Thread-Index: AQHTcPxXLC5iLYc3mUGY2brabaCBKqM8efjQ Date: Sun, 10 Dec 2017 13:52:15 +0000 Message-ID: <4A89E2EF3DFEDB4C8BFDE51014F606A14E18E283@SHSMSX104.ccr.corp.intel.com> References: <1263998052.1770898.1512830709571.ref@mail.yahoo.com> <1263998052.1770898.1512830709571@mail.yahoo.com> In-Reply-To: <1263998052.1770898.1512830709571@mail.yahoo.com> Accept-Language: en-US X-MS-Has-Attach: X-MS-TNEF-Correlator: dlp-product: dlpe-windows dlp-version: 11.0.0.116 dlp-reaction: no-action x-originating-ip: [10.239.127.40] MIME-Version: 1.0 Subject: Re: [PATCH 4/4] BaseTools: resolve initialization order errors in VfrFormPkg.h X-BeenThere: edk2-devel@lists.01.org X-Mailman-Version: 2.1.22 Precedence: list List-Id: EDK II Development List-Unsubscribe: , List-Archive: List-Post: List-Help: List-Subscribe: , X-List-Received-Date: Sun, 10 Dec 2017 13:47:45 -0000 Content-Language: en-US Content-Type: text/plain; charset="us-ascii" Content-Transfer-Encoding: quoted-printable I think these patches resolves CLANG build issues in BaseTools. Do you veri= fy them with GCC or VS tool chain? > -----Original Message----- > From: edk2-devel [mailto:edk2-devel-bounces@lists.01.org] On Behalf Of Ze= nith432 > Sent: Saturday, December 9, 2017 10:45 PM > To: edk2-devel@lists.01.org > Subject: [edk2] [PATCH 4/4] BaseTools: resolve initialization order error= s in VfrFormPkg.h >=20 > clang generates many warnings > warning: field 'XXX' is uninitialized when used here [-Wuninitialized] > for VfrFormPkg.h. >=20 > VfrFormPkg.h defines many classes derived from CIfrObj (along with other = base classes.) > Each of these derived classes defines a non-static member field that serv= es as a duplicate pointer > to an original pointer defined in the CIfrObj base class, but cast to a d= ifferent pointer type. > The derived class constructor passes the duplicate pointer to base class = constructors: > 1) Once passes the address of the duplicate pointer to the CIfrObj constr= uctor to have it initialized. > 2) Then passes the duplicate pointer to one or more subsequent base class= constructors to be used. > Both 1) and 2) constitute undefined behavior in C++. C++ prescribes that= base classes are initialized > before non-static members when initializing a derived class. So when bas= e class constructors are executing, > it is not permitted to assume any non-static members of the derived class= exist (even to the stage of having > their storage allocated.) >=20 > clang does not issue warnings for 1), but issues warnings -Wuninitialized= for 2). >=20 > This coding methodology is resolved as follows: > a) The CIfrObj object accessor method for retrieving the original pointer= is revised to a template member > function that returns the original pointer cast to a desired target type. > b) The call to CIfrObj constructor is no longer used to initialize the du= plicate pointer in the derived class. > c) Any subsequent calls to a base class constructor that need to use the = pointer, retrieve it from the CIfrObj > base class using the template accessor method. > d) If the derived class makes no further use of the pointer, then the dup= licate pointer defined in it is eliminated. > e) If the derived class needs the duplicate pointer for other use, the du= plicate pointer remains in > the derived class and is initialized in proper order from the original po= inter in CIfrObj. > f) Existing source code that previously used the CIfrObj pointer accessor= method is revised to use the template method. >=20 > Contributed-under: TianoCore Contribution Agreement 1.1 > Signed-off-by: Zenith432 > --- > BaseTools/Source/C/VfrCompile/VfrFormPkg.cpp | 4 +- > BaseTools/Source/C/VfrCompile/VfrFormPkg.h | 659 ++++++++++-----------= ------ > BaseTools/Source/C/VfrCompile/VfrSyntax.g | 8 +- > 3 files changed, 257 insertions(+), 414 deletions(-) >=20 > diff --git a/BaseTools/Source/C/VfrCompile/VfrFormPkg.cpp b/BaseTools/Sou= rce/C/VfrCompile/VfrFormPkg.cpp > index b8350623..3985da22 100644 > --- a/BaseTools/Source/C/VfrCompile/VfrFormPkg.cpp > +++ b/BaseTools/Source/C/VfrCompile/VfrFormPkg.cpp > @@ -839,7 +839,7 @@ CFormPkg::DeclarePendingQuestion ( > // DisableIf > CIfrDisableIf DIObj; > DIObj.SetLineNo (LineNo); > - *InsertOpcodeAddr =3D DIObj.GetObjBinAddr (); > + *InsertOpcodeAddr =3D DIObj.GetObjBinAddr(); >=20 > //TrueOpcode > CIfrTrue TObj (LineNo); > @@ -1920,7 +1920,7 @@ CIfrRecordInfoDB::IfrCreateDefaultForQuestion ( > Obj =3D new CIfrObj (pOpHead->OpCode, NULL, pSNode->mBinBufLen= , FALSE); > assert (Obj !=3D NULL); > Obj->SetLineNo (pSNode->mLineNo); > - ObjBinBuf =3D Obj->GetObjBinAddr(); > + ObjBinBuf =3D Obj->GetObjBinAddr(); > memcpy (ObjBinBuf, pSNode->mIfrBinBuf, (UINTN)pSNode->mBinBufL= en); > delete Obj; > pSNode =3D pSNode->mNext; > diff --git a/BaseTools/Source/C/VfrCompile/VfrFormPkg.h b/BaseTools/Sourc= e/C/VfrCompile/VfrFormPkg.h > index 8a22cb24..822f8619 100644 > --- a/BaseTools/Source/C/VfrCompile/VfrFormPkg.h > +++ b/BaseTools/Source/C/VfrCompile/VfrFormPkg.h > @@ -278,8 +278,9 @@ public: > mLineNo =3D LineNo; > } >=20 > - inline CHAR8 * GetObjBinAddr (VOID) { > - return mObjBinBuf; > + template > + inline T * GetObjBinAddr (VOID) { > + return reinterpret_cast(mObjBinBuf); > } >=20 > inline UINT32 GetObjBinOffset (VOID) { > @@ -665,8 +666,8 @@ private: > EFI_GUID *mClassGuid; >=20 > public: > - CIfrFormSet (UINT8 Size) : CIfrObj (EFI_IFR_FORM_SET_OP, (CHAR8 **)&mF= ormSet, Size), > - CIfrOpHeader (EFI_IFR_FORM_SET_OP, &mFormSet->Header,= Size) { > + CIfrFormSet (UINT8 Size) : CIfrObj (EFI_IFR_FORM_SET_OP, (CHAR8 **)NUL= L, Size), > + CIfrOpHeader (EFI_IFR_FORM_SET_OP, &(GetObjBinAddr())->Header, Size), > mFormSet(GetObjBinAddr()) { > mFormSet->Help =3D EFI_STRING_ID_INVALID; > mFormSet->FormSetTitle =3D EFI_STRING_ID_INVALID; > mFormSet->Flags =3D 0; > @@ -696,12 +697,9 @@ public: > }; >=20 > 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) {} > }; >=20 > class CIfrDefaultStore : public CIfrObj, public CIfrOpHeader { > @@ -709,8 +707,8 @@ private: > EFI_IFR_DEFAULTSTORE *mDefaultStore; >=20 > public: > - CIfrDefaultStore () : CIfrObj (EFI_IFR_DEFAULTSTORE_OP, (CHAR8 **)&mDe= faultStore), > - CIfrOpHeader (EFI_IFR_DEFAULTSTORE_OP, &mDefaultS= tore->Header) { > + CIfrDefaultStore () : CIfrObj (EFI_IFR_DEFAULTSTORE_OP), > + CIfrOpHeader (EFI_IFR_DEFAULTSTORE_OP, &(GetObjBi= nAddr())->Header), > mDefaultStore(GetObjBinAddr()) { > mDefaultStore->DefaultId =3D EFI_VARSTORE_ID_INVALID; > mDefaultStore->DefaultName =3D EFI_STRING_ID_INVALID; > } > @@ -751,8 +749,8 @@ private: > EFI_IFR_FORM *mForm; >=20 > 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 =3D 0; > mForm->FormTitle =3D EFI_STRING_ID_INVALID; > } > @@ -783,8 +781,8 @@ private: > EFI_IFR_FORM_MAP_METHOD *mMethodMap; >=20 > public: > - CIfrFormMap () : CIfrObj (EFI_IFR_FORM_MAP_OP, (CHAR8 **)&mFormMap, si= zeof (EFI_IFR_FORM_MAP), TRUE), > - CIfrOpHeader (EFI_IFR_FORM_MAP_OP, &mFormMap->Header)= { > + 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 =3D 0; > mMethodMap =3D (EFI_IFR_FORM_MAP_METHOD *) (mFormMap + 1); > } > @@ -820,8 +818,8 @@ private: > EFI_IFR_VARSTORE *mVarStore; >=20 > 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 =3D EFI_VARSTORE_ID_INVALID; > mVarStore->Size =3D 0; > memset (&mVarStore->Guid, 0, sizeof (EFI_GUID)); > @@ -860,8 +858,8 @@ private: > EFI_IFR_VARSTORE_EFI *mVarStoreEfi; >=20 > public: > - CIfrVarStoreEfi () : CIfrObj (EFI_IFR_VARSTORE_EFI_OP, (CHAR8 **)&mVar= StoreEfi, sizeof (EFI_IFR_VARSTORE_EFI), TRUE), > - CIfrOpHeader (EFI_IFR_VARSTORE_EFI_OP, &mVarStoreE= fi->Header) { > + CIfrVarStoreEfi () : CIfrObj (EFI_IFR_VARSTORE_EFI_OP, (CHAR8 **)NULL,= sizeof (EFI_IFR_VARSTORE_EFI), TRUE), > + CIfrOpHeader (EFI_IFR_VARSTORE_EFI_OP, &(GetObjBin= Addr())->Header), > mVarStoreEfi(GetObjBinAddr()) { > mVarStoreEfi->VarStoreId =3D EFI_VAROFFSET_INVALID; > mVarStoreEfi->Size =3D 0; > memset (&mVarStoreEfi->Guid, 0, sizeof (EFI_GUID)); > @@ -916,8 +914,8 @@ private: > EFI_IFR_VARSTORE_NAME_VALUE *mVarStoreNameValue; >=20 > public: > - CIfrVarStoreNameValue () : CIfrObj (EFI_IFR_VARSTORE_NAME_VALUE_OP, (C= HAR8 **)&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 =3D EFI_VAROFFSET_INVALID; > memset (&mVarStoreNameValue->Guid, 0, sizeof (EFI_GUID)); > } > @@ -936,8 +934,8 @@ private: > EFI_IFR_IMAGE *mImage; >=20 > public: > - CIfrImage () : CIfrObj (EFI_IFR_IMAGE_OP, (CHAR8 **)&mImage), > - CIfrOpHeader (EFI_IFR_IMAGE_OP, &mImage->Header) { > + CIfrImage () : CIfrObj (EFI_IFR_IMAGE_OP), > + CIfrOpHeader (EFI_IFR_IMAGE_OP, &(GetObjBinAddr())->Header), > mImage(GetObjBinAddr()) { > mImage->Id =3D EFI_IMAGE_ID_INVALID; > } >=20 > @@ -947,23 +945,17 @@ public: > }; >=20 > class CIfrModal : public CIfrObj, public CIfrOpHeader { > -private: > - EFI_IFR_MODAL_TAG *mModal; > - > public: > - CIfrModal () : CIfrObj (EFI_IFR_MODAL_TAG_OP, (CHAR8 **)&mModal), > - CIfrOpHeader (EFI_IFR_MODAL_TAG_OP, &mModal->Header) { > + CIfrModal () : CIfrObj (EFI_IFR_MODAL_TAG_OP), > + CIfrOpHeader (EFI_IFR_MODAL_TAG_OP, &(GetObjBinAddr())->Header) { > } > }; >=20 >=20 > class CIfrLocked : public CIfrObj, public CIfrOpHeader { > -private: > - EFI_IFR_LOCKED *mLocked; > - > 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) {} > }; >=20 > class CIfrRule : public CIfrObj, public CIfrOpHeader { > @@ -971,9 +963,8 @@ private: > EFI_IFR_RULE *mRule; >=20 > 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 =3D EFI_RULE_ID_INVALID; > } >=20 > @@ -994,8 +985,8 @@ public: > IN UINT16 DefaultId =3D EFI_HII_DEFAULT_CLASS_STANDARD, > IN UINT8 Type =3D EFI_IFR_TYPE_OTHER, > IN EFI_IFR_TYPE_VALUE Value =3D gZeroEfiIfrTypeValue > - ) : CIfrObj (EFI_IFR_DEFAULT_OP, (CHAR8 **)&mDefault, Size), > - CIfrOpHeader (EFI_IFR_DEFAULT_OP, &mDefault->Header, Size) { > + ) : CIfrObj (EFI_IFR_DEFAULT_OP, (CHAR8 **)NULL, Size), > + CIfrOpHeader (EFI_IFR_DEFAULT_OP, &(GetObjBinAddr())->Header, Size), > mDefault(GetObjBinAddr()) { > mDefault->Type =3D Type; > mDefault->DefaultId =3D DefaultId; > memmove (&(mDefault->Value), &Value, Size - OFFSET_OF (EFI_IFR_DEFAU= LT, Value)); > @@ -1022,8 +1013,8 @@ public: > CIfrDefault2 ( > IN UINT16 DefaultId =3D EFI_HII_DEFAULT_CLASS_STANDARD, > IN UINT8 Type =3D EFI_IFR_TYPE_OTHER > - ) : CIfrObj (EFI_IFR_DEFAULT_OP, (CHAR8 **)&mDefault, sizeof (EFI_IF= R_DEFAULT_2)), > - CIfrOpHeader (EFI_IFR_DEFAULT_OP, &mDefault->Header, sizeof (EFI= _IFR_DEFAULT_2)) { > + ) : CIfrObj (EFI_IFR_DEFAULT_OP, (CHAR8 **)NULL, sizeof (EFI_IFR_DEF= AULT_2)), > + CIfrOpHeader (EFI_IFR_DEFAULT_OP, &(GetObjBinAddr())->Header, sizeof (EFI_IFR_DEFAULT_2)), > mDefault(GetObjBinAddr()) { > mDefault->Type =3D Type; > mDefault->DefaultId =3D DefaultId; > } > @@ -1038,32 +1029,23 @@ public: > }; >=20 > class CIfrValue : public CIfrObj, public CIfrOpHeader{ > -private: > - EFI_IFR_VALUE *mValue; > - > public: > - CIfrValue () : CIfrObj (EFI_IFR_VALUE_OP, (CHAR8 **)&mValue), > - CIfrOpHeader (EFI_IFR_VALUE_OP, &mValue->Header) {} > + CIfrValue () : CIfrObj (EFI_IFR_VALUE_OP), > + CIfrOpHeader (EFI_IFR_VALUE_OP, &(GetObjBinAddr())->Header) {} >=20 > }; >=20 > class CIfrRead : public CIfrObj, public CIfrOpHeader{ > -private: > - EFI_IFR_READ *mRead; > - > public: > - CIfrRead () : CIfrObj (EFI_IFR_READ_OP, (CHAR8 **)&mRead), > - CIfrOpHeader (EFI_IFR_READ_OP, &mRead->Header) {} > + CIfrRead () : CIfrObj (EFI_IFR_READ_OP), > + CIfrOpHeader (EFI_IFR_READ_OP, &(GetObjBinAddr())->Header) {} >=20 > }; >=20 > class CIfrWrite : public CIfrObj, public CIfrOpHeader{ > -private: > - EFI_IFR_WRITE *mWrite; > - > public: > - CIfrWrite () : CIfrObj (EFI_IFR_WRITE_OP, (CHAR8 **)&mWrite), > - CIfrOpHeader (EFI_IFR_WRITE_OP, &mWrite->Header) {} > + CIfrWrite () : CIfrObj (EFI_IFR_WRITE_OP), > + CIfrOpHeader (EFI_IFR_WRITE_OP, &(GetObjBinAddr())->Header) {} >=20 > }; >=20 > @@ -1074,8 +1056,8 @@ private: > public: > CIfrGet ( > IN UINT32 LineNo > - ) : CIfrObj (EFI_IFR_GET_OP, (CHAR8 **)&mGet), > - CIfrOpHeader (EFI_IFR_GET_OP, &mGet->Header) { > + ) : CIfrObj (EFI_IFR_GET_OP), > + CIfrOpHeader (EFI_IFR_GET_OP, &(GetObjBinAddr())->Hea= der), mGet(GetObjBinAddr()) { > SetLineNo (LineNo); > } >=20 > @@ -1094,8 +1076,8 @@ private: > public: > CIfrSet ( > IN UINT32 LineNo > - ) : CIfrObj (EFI_IFR_SET_OP, (CHAR8 **)&mSet), > - CIfrOpHeader (EFI_IFR_SET_OP, &mSet->Header) { > + ) : CIfrObj (EFI_IFR_SET_OP), > + CIfrOpHeader (EFI_IFR_SET_OP, &(GetObjBinAddr())->Hea= der), mSet(GetObjBinAddr()) { > SetLineNo (LineNo); > } >=20 > @@ -1112,9 +1094,9 @@ private: > EFI_IFR_SUBTITLE *mSubtitle; >=20 > 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 =3D 0; > } >=20 > @@ -1132,9 +1114,9 @@ private: > EFI_IFR_TEXT *mText; >=20 > 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())->St= atement), mText(GetObjBinAddr()) { > mText->TextTwo =3D EFI_STRING_ID_INVALID; > } >=20 > @@ -1148,9 +1130,9 @@ private: > EFI_IFR_REF *mRef; >=20 > 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())->Quest= ion), mRef(GetObjBinAddr()) { > mRef->FormId =3D 0; > } >=20 > @@ -1164,9 +1146,9 @@ private: > EFI_IFR_REF2 *mRef2; >=20 > public: > - CIfrRef2 () : CIfrObj (EFI_IFR_REF_OP, (CHAR8 **)&mRef2, sizeof (EFI_I= FR_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())->Que= stion), mRef2(GetObjBinAddr()) { > mRef2->FormId =3D 0; > mRef2->QuestionId =3D EFI_QUESTION_ID_INVALID; > } > @@ -1185,9 +1167,9 @@ private: > EFI_IFR_REF3 *mRef3; >=20 > public: > - CIfrRef3 () : CIfrObj (EFI_IFR_REF_OP, (CHAR8 **)&mRef3, sizeof(EFI_IF= R_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())->Que= stion), mRef3(GetObjBinAddr()) { > mRef3->FormId =3D 0; > mRef3->QuestionId =3D EFI_QUESTION_ID_INVALID; > memset (&mRef3->FormSetId, 0, sizeof (EFI_GUID)); > @@ -1211,9 +1193,9 @@ private: > EFI_IFR_REF4 *mRef4; >=20 > public: > - CIfrRef4 () : CIfrObj (EFI_IFR_REF_OP, (CHAR8 **)&mRef4, sizeof(EFI_IF= R_REF4)), > - CIfrOpHeader (EFI_IFR_REF_OP, &mRef4->Header, sizeof(EFI_= IFR_REF4)), > - 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())->Que= stion), mRef4(GetObjBinAddr()) { > mRef4->FormId =3D 0; > mRef4->QuestionId =3D EFI_QUESTION_ID_INVALID; > memset (&mRef4->FormSetId, 0, sizeof (EFI_GUID)); > @@ -1238,13 +1220,10 @@ public: > }; >=20 > class CIfrRef5 : public CIfrObj, public CIfrOpHeader, public CIfrQuestio= nHeader { > -private: > - EFI_IFR_REF5 *mRef5; > - > public: > - CIfrRef5 () : CIfrObj (EFI_IFR_REF_OP, (CHAR8 **)&mRef5, sizeof (EFI_I= FR_REF5)), > - CIfrOpHeader (EFI_IFR_REF_OP, &mRef5->Header, sizeof (EFI_= IFR_REF5)), > - CIfrQuestionHeader (&mRef5->Question) { > + 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())->Ques= tion) { > } > }; >=20 > @@ -1253,9 +1232,9 @@ private: > EFI_IFR_RESET_BUTTON *mResetButton; >=20 > public: > - CIfrResetButton () : CIfrObj (EFI_IFR_RESET_BUTTON_OP, (CHAR8 **)&mRes= etButton), > - CIfrOpHeader (EFI_IFR_RESET_BUTTON_OP, &mResetBut= ton->Header), > - CIfrStatementHeader (&mResetButton->Statement) { > + CIfrResetButton () : CIfrObj (EFI_IFR_RESET_BUTTON_OP), > + CIfrOpHeader (EFI_IFR_RESET_BUTTON_OP, &(GetObjBi= nAddr())->Header), > + CIfrStatementHeader (&(GetObjBinAddr())->Stateme= nt), > mResetButton(GetObjBinAddr()) { > mResetButton->DefaultId =3D EFI_HII_DEFAULT_CLASS_STANDARD; > } >=20 > @@ -1269,9 +1248,9 @@ private: > EFI_IFR_CHECKBOX *mCheckBox; >=20 > public: > - CIfrCheckBox () : CIfrObj (EFI_IFR_CHECKBOX_OP, (CHAR8 **)&mCheckBox), > - CIfrOpHeader (EFI_IFR_CHECKBOX_OP, &mCheckBox->Head= er), > - CIfrQuestionHeader (&mCheckBox->Question) { > + CIfrCheckBox () : CIfrObj (EFI_IFR_CHECKBOX_OP), > + CIfrOpHeader (EFI_IFR_CHECKBOX_OP, &(GetObjBinAddr<= EFI_IFR_CHECKBOX>())->Header), > + CIfrQuestionHeader (&(GetObjBinAddr())->Question), > mCheckBox(GetObjBinAddr()) { > mCheckBox->Flags =3D 0; > gCurrentQuestion =3D this; > } > @@ -1309,9 +1288,9 @@ private: > EFI_IFR_ACTION *mAction; >=20 > 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 =3D EFI_STRING_ID_INVALID; > } >=20 > @@ -1325,9 +1304,9 @@ private: > EFI_IFR_DATE *mDate; >=20 > 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())->Que= stion), mDate(GetObjBinAddr()) { > mDate->Flags =3D 0; > } >=20 > @@ -1368,10 +1347,10 @@ private: > EFI_IFR_NUMERIC *mNumeric; >=20 > public: > - CIfrNumeric () : CIfrObj (EFI_IFR_NUMERIC_OP, (CHAR8 **)&mNumeric, siz= eof (EFI_IFR_NUMERIC), TRUE), > - CIfrOpHeader (EFI_IFR_NUMERIC_OP, &mNumeric->Header), > - CIfrQuestionHeader (&mNumeric->Question), > - CIfrMinMaxStepData (&mNumeric->data, TRUE) { > + 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 =3D EFI_IFR_NUMERIC_SIZE_1 | EFI_IFR_DISPLAY_UINT_D= EC; > gCurrentQuestion =3D this; > gCurrentMinMaxData =3D this; > @@ -1397,7 +1376,7 @@ public: > // > // Update the buffer pointer used by other class. > // > - mNumeric =3D (EFI_IFR_NUMERIC *) GetObjBinAddr(); > + mNumeric =3D GetObjBinAddr(); > UpdateHeader (&mNumeric->Header); > UpdateCIfrQuestionHeader(&mNumeric->Question); > UpdateCIfrMinMaxStepData(&mNumeric->data); > @@ -1445,10 +1424,10 @@ private: > EFI_IFR_ONE_OF *mOneOf; >=20 > public: > - CIfrOneOf () : CIfrObj (EFI_IFR_ONE_OF_OP, (CHAR8 **)&mOneOf, sizeof (= EFI_IFR_ONE_OF), TRUE), > - 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 =3D 0; > gCurrentQuestion =3D this; > gCurrentMinMaxData =3D this; > @@ -1506,7 +1485,7 @@ public: > // > // Update the buffer pointer used by other class. > // > - mOneOf =3D (EFI_IFR_ONE_OF *) GetObjBinAddr(); > + mOneOf =3D GetObjBinAddr(); > UpdateHeader (&mOneOf->Header); > UpdateCIfrQuestionHeader(&mOneOf->Question); > UpdateCIfrMinMaxStepData(&mOneOf->data); > @@ -1518,9 +1497,9 @@ private: > EFI_IFR_STRING *mString; >=20 > 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 =3D 0; > mString->MinSize =3D 0; > mString->MaxSize =3D 0; > @@ -1560,9 +1539,9 @@ private: > EFI_IFR_PASSWORD *mPassword; >=20 > public: > - CIfrPassword () : CIfrObj (EFI_IFR_PASSWORD_OP, (CHAR8 **)&mPassword), > - CIfrOpHeader (EFI_IFR_PASSWORD_OP, &mPassword->Heade= r), > - CIfrQuestionHeader (&mPassword->Question) { > + CIfrPassword () : CIfrObj (EFI_IFR_PASSWORD_OP), > + CIfrOpHeader (EFI_IFR_PASSWORD_OP, &(GetObjBinAddr())->Header), > + CIfrQuestionHeader (&(GetObjBinAddr())->Question), > mPassword(GetObjBinAddr()) { > mPassword->MinSize =3D 0; > mPassword->MaxSize =3D 0; > gCurrentQuestion =3D this; > @@ -1586,9 +1565,9 @@ private: > EFI_IFR_ORDERED_LIST *mOrderedList; >=20 > public: > - CIfrOrderedList () : CIfrObj (EFI_IFR_ORDERED_LIST_OP, (CHAR8 **)&mOrd= eredList), > - CIfrOpHeader (EFI_IFR_ORDERED_LIST_OP, &mOrderedLi= st->Header), > - CIfrQuestionHeader (&mOrderedList->Question) { > + CIfrOrderedList () : CIfrObj (EFI_IFR_ORDERED_LIST_OP), > + CIfrOpHeader (EFI_IFR_ORDERED_LIST_OP, &(GetObjBin= Addr())->Header), > + CIfrQuestionHeader (&(GetObjBinAddr())->Question), > mOrderedList(GetObjBinAddr()) { > mOrderedList->MaxContainers =3D 0; > mOrderedList->Flags =3D 0; > gCurrentQuestion =3D this; > @@ -1627,9 +1606,9 @@ private: > EFI_IFR_TIME *mTime; >=20 > 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())->Qu= estion), mTime(GetObjBinAddr()) { > mTime->Flags =3D 0; > } >=20 > @@ -1666,31 +1645,21 @@ public: > }; >=20 > class CIfrDisableIf : public CIfrObj, public CIfrOpHeader { > -private: > - EFI_IFR_DISABLE_IF *mDisableIf; > - > public: > - CIfrDisableIf () : CIfrObj (EFI_IFR_DISABLE_IF_OP, (CHAR8 **)&mDisable= If), > - mDisableIf ((EFI_IFR_DISABLE_IF *) GetObjBinAddr()), > - CIfrOpHeader (EFI_IFR_DISABLE_IF_OP, &mDisableIf->Hea= der) {} > + CIfrDisableIf () : CIfrObj (EFI_IFR_DISABLE_IF_OP), > + CIfrOpHeader (EFI_IFR_DISABLE_IF_OP, &(GetObjBinAddr<= EFI_IFR_DISABLE_IF>())->Header) {} > }; >=20 > class CIfrSuppressIf : public CIfrObj, public CIfrOpHeader { > -private: > - EFI_IFR_SUPPRESS_IF *mSuppressIf; > - > public: > - CIfrSuppressIf () : CIfrObj (EFI_IFR_SUPPRESS_IF_OP, (CHAR8 **)&mSuppr= essIf), > - CIfrOpHeader (EFI_IFR_SUPPRESS_IF_OP, &mSuppressIf-= >Header) {} > + CIfrSuppressIf () : CIfrObj (EFI_IFR_SUPPRESS_IF_OP), > + CIfrOpHeader (EFI_IFR_SUPPRESS_IF_OP, &(GetObjBinAd= dr())->Header) {} > }; >=20 > class CIfrGrayOutIf : public CIfrObj, public CIfrOpHeader { > -private: > - EFI_IFR_GRAY_OUT_IF *mGrayOutIf; > - > public: > - CIfrGrayOutIf () : CIfrObj (EFI_IFR_GRAY_OUT_IF_OP, (CHAR8 **)&mGrayOu= tIf), > - CIfrOpHeader (EFI_IFR_GRAY_OUT_IF_OP, &mGrayOutIf->H= eader) {} > + CIfrGrayOutIf () : CIfrObj (EFI_IFR_GRAY_OUT_IF_OP), > + CIfrOpHeader (EFI_IFR_GRAY_OUT_IF_OP, &(GetObjBinAdd= r())->Header) {} > }; >=20 > class CIfrInconsistentIf : public CIfrObj, public CIfrOpHeader { > @@ -1698,8 +1667,8 @@ private: > EFI_IFR_INCONSISTENT_IF *mInconsistentIf; >=20 > public: > - CIfrInconsistentIf () : CIfrObj (EFI_IFR_INCONSISTENT_IF_OP, (CHAR8 **= )&mInconsistentIf), > - CIfrOpHeader (EFI_IFR_INCONSISTENT_IF_OP, &mInco= nsistentIf->Header) { > + CIfrInconsistentIf () : CIfrObj (EFI_IFR_INCONSISTENT_IF_OP), > + CIfrOpHeader (EFI_IFR_INCONSISTENT_IF_OP, > &(GetObjBinAddr())->Header), mInconsistentIf(Get= ObjBinAddr()) { > mInconsistentIf->Error =3D EFI_STRING_ID_INVALID; > } >=20 > @@ -1713,8 +1682,8 @@ private: > EFI_IFR_WARNING_IF *mWarningIf; >=20 > public: > - CIfrWarningIf () : CIfrObj (EFI_IFR_WARNING_IF_OP, (CHAR8 **)&mWarning= If), > - CIfrOpHeader (EFI_IFR_WARNING_IF_OP, &mWarningIf= ->Header) { > + CIfrWarningIf () : CIfrObj (EFI_IFR_WARNING_IF_OP), > + CIfrOpHeader (EFI_IFR_WARNING_IF_OP, &(GetObjBin= Addr())->Header), > mWarningIf(GetObjBinAddr()) { > mWarningIf->Warning =3D EFI_STRING_ID_INVALID; > mWarningIf->TimeOut =3D 0; > } > @@ -1733,8 +1702,8 @@ private: > EFI_IFR_NO_SUBMIT_IF *mNoSubmitIf; >=20 > public: > - CIfrNoSubmitIf () : CIfrObj (EFI_IFR_NO_SUBMIT_IF_OP, (CHAR8 **)&mNoSu= bmitIf), > - CIfrOpHeader (EFI_IFR_NO_SUBMIT_IF_OP, &mNoSubmitIf= ->Header) { > + CIfrNoSubmitIf () : CIfrObj (EFI_IFR_NO_SUBMIT_IF_OP), > + CIfrOpHeader (EFI_IFR_NO_SUBMIT_IF_OP, &(GetObjBinA= ddr())->Header), > mNoSubmitIf(GetObjBinAddr()) { > mNoSubmitIf->Error =3D EFI_STRING_ID_INVALID; > } >=20 > @@ -1748,8 +1717,8 @@ private: > EFI_IFR_REFRESH *mRefresh; >=20 > 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 =3D 0; > } >=20 > @@ -1763,8 +1732,8 @@ private: > EFI_IFR_REFRESH_ID *mRefreshId; >=20 > public: > - CIfrRefreshId () : CIfrObj (EFI_IFR_REFRESH_ID_OP, (CHAR8 **)&mRefresh= Id), > - CIfrOpHeader (EFI_IFR_REFRESH_ID_OP, &mRefreshId->Header) { > + CIfrRefreshId () : CIfrObj (EFI_IFR_REFRESH_ID_OP), > + CIfrOpHeader (EFI_IFR_REFRESH_ID_OP, &(GetObjBinAddr())->Header), > mRefreshId(GetObjBinAddr()) { > memset (&mRefreshId->RefreshEventGroupId, 0, sizeof (EFI_GUID)); > } >=20 > @@ -1778,8 +1747,8 @@ private: > EFI_IFR_VARSTORE_DEVICE *mVarStoreDevice; >=20 > public: > - CIfrVarStoreDevice () : CIfrObj (EFI_IFR_VARSTORE_DEVICE_OP, (CHAR8 **= )&mVarStoreDevice), > - CIfrOpHeader (EFI_IFR_VARSTORE_DEVICE_OP, &mVa= rStoreDevice->Header) { > + CIfrVarStoreDevice () : CIfrObj (EFI_IFR_VARSTORE_DEVICE_OP), > + CIfrOpHeader (EFI_IFR_VARSTORE_DEVICE_OP, > &(GetObjBinAddr())->Header), mVarStoreDevice(Get= ObjBinAddr()) { > mVarStoreDevice->DevicePath =3D EFI_STRING_ID_INVALID; > } >=20 > @@ -1793,8 +1762,8 @@ private: > EFI_IFR_ONE_OF_OPTION *mOneOfOption; >=20 > public: > - CIfrOneOfOption (UINT8 Size) : CIfrObj (EFI_IFR_ONE_OF_OPTION_OP, (CHA= R8 **)&mOneOfOption, Size), > - CIfrOpHeader (EFI_IFR_ONE_OF_OPTION_OP, &mOneOfOp= tion->Header, Size) { > + CIfrOneOfOption (UINT8 Size) : CIfrObj (EFI_IFR_ONE_OF_OPTION_OP, (CHA= R8 **)NULL, Size), > + CIfrOpHeader (EFI_IFR_ONE_OF_OPTION_OP, &(GetObjB= inAddr())->Header, > Size), mOneOfOption(GetObjBinAddr()) { > mOneOfOption->Flags =3D 0; > mOneOfOption->Option =3D EFI_STRING_ID_INVALID; > mOneOfOption->Type =3D EFI_IFR_TYPE_OTHER; > @@ -1868,8 +1837,8 @@ private: > EFI_IFR_GUID_CLASS *mClass; >=20 > public: > - CIfrClass () : CIfrObj (EFI_IFR_GUID_OP, (CHAR8 **)&mClass, sizeof (EF= I_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_I= FR_GUID_CLASS)), > + CIfrOpHeader (EFI_IFR_GUID_OP, &(GetObjBinAddr())->Header, sizeof > (EFI_IFR_GUID_CLASS)), mClass(GetObjBinAddr()) { > mClass->ExtendOpCode =3D EFI_IFR_EXTEND_OP_CLASS; > mClass->Guid =3D IfrTianoGuid; > mClass->Class =3D EFI_NON_DEVICE_CLASS; > @@ -1885,8 +1854,8 @@ private: > EFI_IFR_GUID_SUBCLASS *mSubClass; >=20 > public: > - CIfrSubClass () : CIfrObj (EFI_IFR_GUID_OP, (CHAR8 **)&mSubClass, size= of (EFI_IFR_GUID_SUBCLASS)), > - CIfrOpHeader (EFI_IFR_GUID_OP, &mSubClass->Header, s= izeof (EFI_IFR_GUID_SUBCLASS)) { > + CIfrSubClass () : CIfrObj (EFI_IFR_GUID_OP, (CHAR8 **)NULL, sizeof (EF= I_IFR_GUID_SUBCLASS)), > + CIfrOpHeader (EFI_IFR_GUID_OP, &(GetObjBinAddr())->Header, sizeof > (EFI_IFR_GUID_SUBCLASS)), mSubClass(GetObjBinAddr(= )) { > mSubClass->ExtendOpCode =3D EFI_IFR_EXTEND_OP_SUBCLASS; > mSubClass->Guid =3D IfrTianoGuid; > mSubClass->SubClass =3D EFI_SETUP_APPLICATION_SUBCLASS; > @@ -1902,8 +1871,8 @@ private: > EFI_IFR_GUID_LABEL *mLabel; >=20 > public: > - CIfrLabel () : CIfrObj (EFI_IFR_GUID_OP, (CHAR8 **)&mLabel, sizeof (EF= I_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_I= FR_GUID_LABEL)), > + CIfrOpHeader (EFI_IFR_GUID_OP, &(GetObjBinAddr())->Header, sizeof > (EFI_IFR_GUID_LABEL)), mLabel(GetObjBinAddr()) { > mLabel->ExtendOpCode =3D EFI_IFR_EXTEND_OP_LABEL; > mLabel->Guid =3D IfrTianoGuid; > } > @@ -1918,8 +1887,8 @@ private: > EFI_IFR_GUID_BANNER *mBanner; >=20 > public: > - CIfrBanner () : CIfrObj (EFI_IFR_GUID_OP, (CHAR8 **)&mBanner, sizeof (= EFI_IFR_GUID_BANNER)), > - CIfrOpHeader (EFI_IFR_GUID_OP, &mBanner->Header, sizeo= f (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 =3D EFI_IFR_EXTEND_OP_BANNER; > mBanner->Guid =3D IfrTianoGuid; > } > @@ -1946,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_G= UID_OPTIONKEY)), > - CIfrOpHeader (EFI_IFR_GUID_OP, &mOptionKey->Header, sizeof (EFI_IF= R_GUID_OPTIONKEY)) { > + ) : CIfrObj (EFI_IFR_GUID_OP, (CHAR8 **)NULL, sizeof (EFI_IFR_GUID_OPT= IONKEY)), > + CIfrOpHeader (EFI_IFR_GUID_OP, &(GetObjBinAddr())->Header, sizeof > (EFI_IFR_GUID_OPTIONKEY)), mOptionKey(GetObjBinAddr()) { > mOptionKey->ExtendOpCode =3D EFI_IFR_EXTEND_OP_OPTIONKEY; > mOptionKey->Guid =3D IfrFrameworkGuid; > mOptionKey->QuestionId =3D QuestionId; > @@ -1964,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_G= UID_VAREQNAME)), > - CIfrOpHeader (EFI_IFR_GUID_OP, &mVarEqName->Header, sizeof (EFI_IF= R_GUID_VAREQNAME)) { > + ) : CIfrObj (EFI_IFR_GUID_OP, (CHAR8 **)NULL, sizeof (EFI_IFR_GUID_VAR= EQNAME)), > + CIfrOpHeader (EFI_IFR_GUID_OP, &(GetObjBinAddr())->Header, sizeof > (EFI_IFR_GUID_VAREQNAME)), mVarEqName(GetObjBinAddr()) { > mVarEqName->ExtendOpCode =3D EFI_IFR_EXTEND_OP_VAREQNAME; > mVarEqName->Guid =3D IfrFrameworkGuid; > mVarEqName->QuestionId =3D QuestionId; > @@ -1978,8 +1947,8 @@ private: > EFI_IFR_GUID_TIMEOUT *mTimeout; >=20 > public: > - CIfrTimeout (IN UINT16 Timeout =3D 0) : CIfrObj (EFI_IFR_GUID_OP, (CHA= R8 **)&mTimeout, sizeof (EFI_IFR_GUID_TIMEOUT)), > - CIfrOpHeader (EFI_IFR_GUID_OP, &= mTimeout->Header, sizeof > (EFI_IFR_GUID_TIMEOUT)) { > + CIfrTimeout (IN UINT16 Timeout =3D 0) : CIfrObj (EFI_IFR_GUID_OP, (CHA= R8 **)NULL, sizeof (EFI_IFR_GUID_TIMEOUT)), > + CIfrOpHeader (EFI_IFR_GUID_OP, > &(GetObjBinAddr())->Header, sizeof (EFI_IFR_GUID_TI= MEOUT)), > mTimeout(GetObjBinAddr()) { > mTimeout->ExtendOpCode =3D EFI_IFR_EXTEND_OP_TIMEOUT; > mTimeout->Guid =3D IfrTianoGuid; > mTimeout->TimeOut =3D Timeout; > @@ -1995,8 +1964,8 @@ private: > EFI_IFR_GUID *mGuid; >=20 > public: > - CIfrGuid (UINT8 Size) : CIfrObj (EFI_IFR_GUID_OP, (CHAR8 **)&mGuid, si= zeof (EFI_IFR_GUID)+Size), > - CIfrOpHeader (EFI_IFR_GUID_OP, &mGuid->Header, sizeof = (EFI_IFR_GUID)+Size) { > + CIfrGuid (UINT8 Size) : CIfrObj (EFI_IFR_GUID_OP, (CHAR8 **)NULL, size= of (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)); > } >=20 > @@ -2010,14 +1979,11 @@ public: > }; >=20 > class CIfrDup : public CIfrObj, public CIfrOpHeader { > -private: > - EFI_IFR_DUP *mDup; > - > 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())->Hea= der) { > SetLineNo (LineNo); > } > }; > @@ -2029,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 =3D EFI_QUESTION_ID_INVALID; > mEqIdId->QuestionId2 =3D EFI_QUESTION_ID_INVALID; > @@ -2068,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 =3D EFI_QUESTION_ID_INVALID; > } > @@ -2098,8 +2064,8 @@ private: > public: > CIfrEqIdList ( > IN UINT32 LineNo > - ) : CIfrObj (EFI_IFR_EQ_ID_VAL_LIST_OP, (CHAR8 **)&mEqIdVList, sizeof = (EFI_IFR_EQ_ID_VAL_LIST), TRUE), > - CIfrOpHeader (EFI_IFR_EQ_ID_VAL_LIST_OP, &mEqIdVList-= >Header) { > + ) : CIfrObj (EFI_IFR_EQ_ID_VAL_LIST_OP, (CHAR8 **)NULL, sizeof (EFI_IF= R_EQ_ID_VAL_LIST), TRUE), > + CIfrOpHeader (EFI_IFR_EQ_ID_VAL_LIST_OP, &(GetObjBinA= ddr())->Header), > mEqIdVList(GetObjBinAddr()) { > SetLineNo (LineNo); > mEqIdVList->QuestionId =3D EFI_QUESTION_ID_INVALID; > mEqIdVList->ListLength =3D 0; > @@ -2109,7 +2075,7 @@ public: > VOID UpdateIfrBuffer ( > ) { > _EMIT_PENDING_OBJ(); > - mEqIdVList =3D (EFI_IFR_EQ_ID_VAL_LIST *) GetObjBinAddr(); > + mEqIdVList =3D GetObjBinAddr(); > UpdateHeader (&mEqIdVList->Header); > } >=20 > @@ -2149,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 =3D EFI_QUESTION_ID_INVALID; > } > @@ -2169,27 +2135,21 @@ public: > }; >=20 > 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); > } > }; >=20 > 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); > } > }; > @@ -2201,8 +2161,8 @@ private: > public: > CIfrQuestionRef3_2 ( > IN UINT32 LineNo > - ) : CIfrObj (EFI_IFR_QUESTION_REF3_OP, (CHAR8 **)&mQuestionRef3_2, siz= eof (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 =3D EFI_STRING_ID_INVALID; > } > @@ -2219,8 +2179,8 @@ private: > public: > CIfrQuestionRef3_3 ( > IN UINT32 LineNo > - ) : CIfrObj (EFI_IFR_QUESTION_REF3_OP, (CHAR8 **)&mQuestionRef3_3, siz= eof (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 =3D EFI_STRING_ID_INVALID; > memset (&mQuestionRef3_3->Guid, 0, sizeof (EFI_GUID)); > @@ -2242,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 =3D EFI_RULE_ID_INVALID; > } > @@ -2260,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 =3D EFI_STRING_ID_INVALID; > } > @@ -2272,27 +2232,21 @@ public: > }; >=20 > 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); > } > }; >=20 > class CIfrThis : public CIfrObj, public CIfrOpHeader { > -private: > - EFI_IFR_THIS *mThis; > - > public: > CIfrThis ( > IN UINT32 LineNo > - ) : CIfrObj (EFI_IFR_THIS_OP, (CHAR8 **)&mThis), > - CIfrOpHeader (EFI_IFR_THIS_OP, &mThis->Header) { > + ) : CIfrObj (EFI_IFR_THIS_OP), > + CIfrOpHeader (EFI_IFR_THIS_OP, &(GetObjBinAddr())->H= eader) { > SetLineNo (LineNo); > } > }; > @@ -2304,8 +2258,8 @@ private: > public: > CIfrSecurity ( > IN UINT32 LineNo > - ) : CIfrObj (EFI_IFR_SECURITY_OP, (CHAR8 **)&mSecurity), > - CIfrOpHeader (EFI_IFR_SECURITY_OP, &mSecurity->Header) { > + ) : CIfrObj (EFI_IFR_SECURITY_OP), > + CIfrOpHeader (EFI_IFR_SECURITY_OP, &(GetObjBinAddr())->Header), > mSecurity(GetObjBinAddr()) { > SetLineNo (LineNo); > memset (&mSecurity->Permissions, 0, sizeof (EFI_GUID)); > } > @@ -2322,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); > } >=20 > @@ -2339,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); > } >=20 > @@ -2356,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); > } >=20 > @@ -2373,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); > } >=20 > @@ -2384,144 +2338,111 @@ public: > }; >=20 > 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())->H= eader) { > SetLineNo (LineNo); > } > }; >=20 > 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); > } > }; >=20 > 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())->Hea= der) { > SetLineNo (LineNo); > } > }; >=20 > 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())->H= eader) { > SetLineNo (LineNo); > } > }; >=20 > 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())->H= eader) { > SetLineNo (LineNo); > } > }; >=20 > 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); > } > }; >=20 > 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); > } > }; >=20 > 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); > } > }; >=20 > 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())->Hea= der) { > SetLineNo (LineNo); > } > }; >=20 > 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); > } > }; >=20 > 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); > } > }; > @@ -2533,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); > } >=20 > @@ -2544,209 +2465,161 @@ public: > }; >=20 > 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); > } > }; >=20 > 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); > } > }; >=20 > 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); > } > }; >=20 > 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())->Hea= der) { > SetLineNo (LineNo); > } > }; >=20 > 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); > } > }; >=20 > 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); > } > }; >=20 > 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())->Hea= der) { > SetLineNo (LineNo); > } > }; >=20 > 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); > } > }; >=20 > 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); > } > }; >=20 > 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); > } > }; >=20 > 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); > } > }; >=20 > 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); > } > }; >=20 > 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); > } > }; >=20 > 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); > } > }; >=20 > class CIfrMap : public CIfrObj, public CIfrOpHeader{ > -private: > - EFI_IFR_MAP *mMap; > - > public: > CIfrMap ( > IN UINT32 LineNo > - ) : CIfrObj (EFI_IFR_MAP_OP, (CHAR8 **)&mMap), > - CIfrOpHeader (EFI_IFR_MAP_OP, &mMap->Header) { > + ) : CIfrObj (EFI_IFR_MAP_OP), > + CIfrOpHeader (EFI_IFR_MAP_OP, &(GetObjBinAddr())->Hea= der) { > SetLineNo (LineNo); > } > }; >=20 > class CIfrMatch : public CIfrObj, public CIfrOpHeader { > -private: > - EFI_IFR_MATCH *mMatch; > - > 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); > } > }; > @@ -2759,113 +2632,89 @@ public: > CIfrMatch2 ( > IN UINT32 LineNo, > IN EFI_GUID *Guid > - ) : CIfrObj (EFI_IFR_MATCH2_OP, (CHAR8 **)&mMatch2), > - CIfrOpHeader (EFI_IFR_MATCH2_OP, &mMatch2->Header) { > + ) : CIfrObj (EFI_IFR_MATCH2_OP), > + CIfrOpHeader (EFI_IFR_MATCH2_OP, &(GetObjBinAddr()= )->Header), > mMatch2(GetObjBinAddr()) { > SetLineNo (LineNo); > memmove (&mMatch2->SyntaxType, Guid, sizeof (EFI_GUID)); > } > }; >=20 > class CIfrMultiply : public CIfrObj, public CIfrOpHeader { > -private: > - EFI_IFR_MULTIPLY *mMultiply; > - > 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); > } > }; >=20 > 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); > } > }; >=20 > 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); > } > }; >=20 > 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())->Heade= r) { > SetLineNo (LineNo); > } > }; >=20 > 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); > } > }; >=20 > 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); > } > }; >=20 > 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); > } > }; >=20 > 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); > } > }; > @@ -2877,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())->H= eader), mFind(GetObjBinAddr()) { > SetLineNo (LineNo); > } >=20 > @@ -2888,27 +2737,21 @@ public: > }; >=20 > 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())->Hea= der) { > SetLineNo (LineNo); > } > }; >=20 > 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); > } > }; > @@ -2920,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())->H= eader), mSpan(GetObjBinAddr()) { > SetLineNo (LineNo); > mSpan->Flags =3D EFI_IFR_FLAGS_FIRST_MATCHING; > } > diff --git a/BaseTools/Source/C/VfrCompile/VfrSyntax.g b/BaseTools/Source= /C/VfrCompile/VfrSyntax.g > index a434eacf..4c7c6f28 100644 > --- a/BaseTools/Source/C/VfrCompile/VfrSyntax.g > +++ b/BaseTools/Source/C/VfrCompile/VfrSyntax.g > @@ -986,7 +986,7 @@ vfrStatementDefaultStore : > << > if (gCVfrDefaultS= tore.DefaultIdRegistered (DefaultId) =3D=3D FALSE) { > CIfrDefaultStor= e DSObj; > - _PCATCH(gCVfrDe= faultStore.RegisterDefaultStore > (DSObj.GetObjBinAddr(), N->getText(), _STOSID(S->getText(), S->getLine())= , DefaultId)), D->getLine(); > + _PCATCH(gCVfrDe= faultStore.RegisterDefaultStore > (DSObj.GetObjBinAddr(), N->getText(), _STOSID(S->getText(), S->get= Line()), DefaultId)), D->getLine(); > DSObj.SetLineNo= (D->getLine()); > DSObj.SetDefaul= tName (_STOSID(S->getText(), S->getLine())); > DSObj.SetDefaul= tId (DefaultId); > @@ -1770,7 +1770,7 @@ vfrFormDefinition : > LObj3.SetNumber = (0xffff); //add end label for UEFI, label > number hardcode 0xffff > } >=20 > - {CIfrEnd EObj; EOb= j.SetLineNo (E->getLine()); mLastFormEndAddr =3D > EObj.GetObjBinAddr (); gAdjustOpcodeOffset =3D EObj.GetObjBinOffset ();} > + {CIfrEnd EObj; EOb= j.SetLineNo (E->getLine()); mLastFormEndAddr =3D > EObj.GetObjBinAddr(); gAdjustOpcodeOffset =3D EObj.GetObjBinOffset= ();} > >> > ";" > ; > @@ -5675,7 +5675,7 @@ EfiVfrParser::_DeclareStandardDefaultStorage ( > // > CIfrDefaultStore DSObj; >=20 > - gCVfrDefaultStore.RegisterDefaultStore (DSObj.GetObjBinAddr(), (CHAR8 = *) "Standard Defaults", EFI_STRING_ID_INVALID, > EFI_HII_DEFAULT_CLASS_STANDARD); > + gCVfrDefaultStore.RegisterDefaultStore (DSObj.GetObjBinAddr(), = (CHAR8 *) "Standard Defaults", EFI_STRING_ID_INVALID, > EFI_HII_DEFAULT_CLASS_STANDARD); > DSObj.SetLineNo (LineNo); > DSObj.SetDefaultName (EFI_STRING_ID_INVALID); > DSObj.SetDefaultId (EFI_HII_DEFAULT_CLASS_STANDARD); > @@ -5685,7 +5685,7 @@ EfiVfrParser::_DeclareStandardDefaultStorage ( > // > CIfrDefaultStore DSObjMF; >=20 > - gCVfrDefaultStore.RegisterDefaultStore (DSObjMF.GetObjBinAddr(), (CHAR= 8 *) "Standard ManuFacturing", EFI_STRING_ID_INVALID, > EFI_HII_DEFAULT_CLASS_MANUFACTURING); > + gCVfrDefaultStore.RegisterDefaultStore (DSObjMF.GetObjBinAddr()= , (CHAR8 *) "Standard ManuFacturing", > EFI_STRING_ID_INVALID, EFI_HII_DEFAULT_CLASS_MANUFACTURING); > DSObjMF.SetLineNo (LineNo); > DSObjMF.SetDefaultName (EFI_STRING_ID_INVALID); > DSObjMF.SetDefaultId (EFI_HII_DEFAULT_CLASS_MANUFACTURING); > -- > 2.14.3 (Apple Git-98) > _______________________________________________ > edk2-devel mailing list > edk2-devel@lists.01.org > https://lists.01.org/mailman/listinfo/edk2-devel