BaseTools: resolve initialization order errors in VfrFormPkg.h

[mirror_edk2.git] / BaseTools / Source / C / VfrCompile / VfrFormPkg.h

diff --git a/BaseTools/Source/C/VfrCompile/VfrFormPkg.h b/BaseTools/Source/C/VfrCompile/VfrFormPkg.h
index 17ab14c021dfacea7f4f1d064bc335dc90306979..822f861983f8c77a1fc4969032dfcd452645ba81 100644 (file)
--- a/BaseTools/Source/C/VfrCompile/VfrFormPkg.h
+++ b/BaseTools/Source/C/VfrCompile/VfrFormPkg.h
@@ -2,7 +2,7 @@
   \r
   The definition of CFormPkg's member function\r
 \r
   \r
   The definition of CFormPkg's member function\r
 \r

-Copyright (c) 2004 - 2016, 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
 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


@@ -278,8 +278,9 @@ public:
     mLineNo = LineNo;\r
   }\r
 \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
   }\r
 \r
   inline UINT32 GetObjBinOffset (VOID) {\r


@@ -567,8 +568,12 @@ public:
     mMinMaxStepData->u8.Step = Step;\r
   }\r
 \r
     mMinMaxStepData->u8.Step = Step;\r
   }\r
 \r

-  UINT64 GetMinData (UINT8 VarType) {\r
+  UINT64 GetMinData (UINT8 VarType, BOOLEAN IsBitVar) {\r

     UINT64 MinValue = 0;\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
     switch (VarType) {\r
     case EFI_IFR_TYPE_NUM_SIZE_64:\r
       MinValue = mMinMaxStepData->u64.MinValue;\r


@@ -588,8 +593,12 @@ public:
     return MinValue;\r
   }\r
 \r
     return MinValue;\r
   }\r
 \r

-  UINT64 GetMaxData (UINT8 VarType) {\r
+  UINT64 GetMaxData (UINT8 VarType, BOOLEAN IsBitVar) {\r

     UINT64 MaxValue = 0;\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
     switch (VarType) {\r
     case EFI_IFR_TYPE_NUM_SIZE_64:\r
       MaxValue = mMinMaxStepData->u64.MaxValue;\r


@@ -609,8 +618,12 @@ public:
     return MaxValue;\r
   }\r
 \r
     return MaxValue;\r
   }\r
 \r

-  UINT64 GetStepData (UINT8 VarType) {\r
+  UINT64 GetStepData (UINT8 VarType, BOOLEAN IsBitVar) {\r

     UINT64 MaxValue = 0;\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
     switch (VarType) {\r
     case EFI_IFR_TYPE_NUM_SIZE_64:\r
       MaxValue = mMinMaxStepData->u64.Step;\r


@@ -653,8 +666,8 @@ private:
   EFI_GUID *mClassGuid;\r
 \r
 public:\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
     mFormSet->Help         = EFI_STRING_ID_INVALID;\r
     mFormSet->FormSetTitle = EFI_STRING_ID_INVALID;\r
     mFormSet->Flags        = 0;\r


@@ -684,12 +697,9 @@ public:
 };\r
 \r
 class CIfrEnd : public CIfrObj, public CIfrOpHeader {\r
 };\r
 \r
 class CIfrEnd : public CIfrObj, public CIfrOpHeader {\r

-private:\r
-  EFI_IFR_END  *mEnd;\r
-\r

 public:\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
 };\r
 \r
 class CIfrDefaultStore : public CIfrObj, public CIfrOpHeader {\r


@@ -697,8 +707,8 @@ private:
   EFI_IFR_DEFAULTSTORE *mDefaultStore;\r
 \r
 public:\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
     mDefaultStore->DefaultId   = EFI_VARSTORE_ID_INVALID;\r
     mDefaultStore->DefaultName = EFI_STRING_ID_INVALID;\r
   }\r


@@ -739,8 +749,8 @@ private:
   EFI_IFR_FORM  *mForm;\r
 \r
 public:\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
     mForm->FormId    = 0;\r
     mForm->FormTitle = EFI_STRING_ID_INVALID;\r
   }\r


@@ -771,8 +781,8 @@ private:
   EFI_IFR_FORM_MAP_METHOD *mMethodMap;\r
 \r
 public:\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
     mFormMap->FormId = 0;\r
     mMethodMap       = (EFI_IFR_FORM_MAP_METHOD *) (mFormMap + 1);\r
   }\r


@@ -808,8 +818,8 @@ private:
   EFI_IFR_VARSTORE *mVarStore;\r
 \r
 public:\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
     mVarStore->VarStoreId = EFI_VARSTORE_ID_INVALID;\r
     mVarStore->Size       = 0;\r
     memset (&mVarStore->Guid, 0, sizeof (EFI_GUID));\r


@@ -848,8 +858,8 @@ private:
   EFI_IFR_VARSTORE_EFI *mVarStoreEfi;\r
 \r
 public:\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
     mVarStoreEfi->VarStoreId = EFI_VAROFFSET_INVALID;\r
     mVarStoreEfi->Size       = 0;\r
     memset (&mVarStoreEfi->Guid, 0, sizeof (EFI_GUID));\r


@@ -904,8 +914,8 @@ private:
   EFI_IFR_VARSTORE_NAME_VALUE *mVarStoreNameValue;\r
 \r
 public:\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
     mVarStoreNameValue->VarStoreId = EFI_VAROFFSET_INVALID;\r
     memset (&mVarStoreNameValue->Guid, 0, sizeof (EFI_GUID));\r
   }\r


@@ -924,8 +934,8 @@ private:
   EFI_IFR_IMAGE *mImage;\r
 \r
 public:\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
     mImage->Id = EFI_IMAGE_ID_INVALID;\r
   }\r
 \r


@@ -935,23 +945,17 @@ public:
 };\r
 \r
 class CIfrModal : public CIfrObj, public CIfrOpHeader {\r
 };\r
 \r
 class CIfrModal : public CIfrObj, public CIfrOpHeader {\r

-private:\r
-  EFI_IFR_MODAL_TAG *mModal;\r
-\r

 public:\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
   }\r
 };\r
 \r
 \r
 class CIfrLocked : public CIfrObj, public CIfrOpHeader {\r

-private:\r
-  EFI_IFR_LOCKED *mLocked;\r
-\r

 public:\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
 };\r
 \r
 class CIfrRule : public CIfrObj, public CIfrOpHeader {\r


@@ -959,9 +963,8 @@ private:
   EFI_IFR_RULE *mRule;\r
 \r
 public:\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
     mRule->RuleId = EFI_RULE_ID_INVALID;\r
   }\r
 \r


@@ -982,8 +985,8 @@ public:
     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
     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
     mDefault->Type      = Type;\r
     mDefault->DefaultId = DefaultId;\r
     memmove (&(mDefault->Value), &Value, Size - OFFSET_OF (EFI_IFR_DEFAULT, Value));\r


@@ -1010,8 +1013,8 @@ public:
   CIfrDefault2 (\r
     IN UINT16             DefaultId = EFI_HII_DEFAULT_CLASS_STANDARD,\r
     IN UINT8              Type      = EFI_IFR_TYPE_OTHER\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
     mDefault->Type      = Type;\r
     mDefault->DefaultId = DefaultId;\r
   }\r


@@ -1026,32 +1029,23 @@ public:
 };\r
 \r
 class CIfrValue : public CIfrObj, public CIfrOpHeader{\r
 };\r
 \r
 class CIfrValue : public CIfrObj, public CIfrOpHeader{\r

-private:\r
-  EFI_IFR_VALUE *mValue;\r
-\r

 public:\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
 \r
 };\r
 \r
 class CIfrRead : public CIfrObj, public CIfrOpHeader{\r

-private:\r
-  EFI_IFR_READ *mRead;\r
-\r

 public:\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
 \r
 };\r
 \r
 class CIfrWrite : public CIfrObj, public CIfrOpHeader{\r

-private:\r
-  EFI_IFR_WRITE *mWrite;\r
-\r

 public:\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
 \r
 };\r
 \r


@@ -1062,8 +1056,8 @@ private:
 public:\r
   CIfrGet (\r
   IN UINT32 LineNo  \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
     SetLineNo (LineNo);\r
   }\r
 \r


@@ -1082,8 +1076,8 @@ private:
 public:\r
   CIfrSet (\r
   IN UINT32 LineNo\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
     SetLineNo (LineNo);\r
   }\r
 \r


@@ -1100,9 +1094,9 @@ private:
   EFI_IFR_SUBTITLE   *mSubtitle;\r
 \r
 public:\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
     mSubtitle->Flags = 0;\r
   }\r
 \r


@@ -1120,9 +1114,9 @@ private:
   EFI_IFR_TEXT *mText;\r
 \r
 public:\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
     mText->TextTwo = EFI_STRING_ID_INVALID;\r
   }\r
 \r


@@ -1136,9 +1130,9 @@ private:
   EFI_IFR_REF *mRef;\r
 \r
 public:\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
     mRef->FormId = 0;\r
   }\r
 \r


@@ -1152,9 +1146,9 @@ private:
   EFI_IFR_REF2 *mRef2;\r
 \r
 public:\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
     mRef2->FormId     = 0;\r
     mRef2->QuestionId = EFI_QUESTION_ID_INVALID;\r
   }\r


@@ -1173,9 +1167,9 @@ private:
   EFI_IFR_REF3 *mRef3;\r
 \r
 public:\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
     mRef3->FormId     = 0;\r
     mRef3->QuestionId = EFI_QUESTION_ID_INVALID;\r
     memset (&mRef3->FormSetId, 0, sizeof (EFI_GUID));\r


@@ -1199,9 +1193,9 @@ private:
   EFI_IFR_REF4 *mRef4;\r
 \r
 public:\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
     mRef4->FormId     = 0;\r
     mRef4->QuestionId = EFI_QUESTION_ID_INVALID;\r
     memset (&mRef4->FormSetId, 0, sizeof (EFI_GUID));\r


@@ -1226,13 +1220,10 @@ public:
 };\r
 \r
 class CIfrRef5 : public CIfrObj, public CIfrOpHeader, public CIfrQuestionHeader {\r
 };\r
 \r
 class CIfrRef5 : public CIfrObj, public CIfrOpHeader, public CIfrQuestionHeader {\r

-private:\r
-  EFI_IFR_REF5 *mRef5;\r
-\r

 public:\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
   }\r
 };\r
 \r


@@ -1241,9 +1232,9 @@ private:
   EFI_IFR_RESET_BUTTON *mResetButton;\r
 \r
 public:\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
     mResetButton->DefaultId = EFI_HII_DEFAULT_CLASS_STANDARD;\r
   }\r
 \r


@@ -1257,9 +1248,9 @@ private:
   EFI_IFR_CHECKBOX *mCheckBox;\r
 \r
 public:\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
     mCheckBox->Flags = 0;\r
     gCurrentQuestion  = this;\r
   }\r


@@ -1297,9 +1288,9 @@ private:
   EFI_IFR_ACTION *mAction;\r
 \r
 public:\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
     mAction->QuestionConfig = EFI_STRING_ID_INVALID;\r
   }\r
 \r


@@ -1313,9 +1304,9 @@ private:
   EFI_IFR_DATE *mDate;\r
 \r
 public:\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
     mDate->Flags = 0;\r
   }\r
 \r


@@ -1356,10 +1347,10 @@ private:
   EFI_IFR_NUMERIC *mNumeric;\r
 \r
 public:\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
     mNumeric->Flags  = EFI_IFR_NUMERIC_SIZE_1 | EFI_IFR_DISPLAY_UINT_DEC;\r
     gCurrentQuestion   = this;\r
     gCurrentMinMaxData = this;\r


@@ -1385,7 +1376,7 @@ public:
     //\r
     // Update the buffer pointer used by other class.\r
     //\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
     UpdateHeader (&mNumeric->Header);\r
     UpdateCIfrQuestionHeader(&mNumeric->Question);\r
     UpdateCIfrMinMaxStepData(&mNumeric->data);\r


@@ -1407,6 +1398,22 @@ public:
     return VFR_RETURN_SUCCESS;\r
   }\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
   UINT8 GetNumericFlags () {\r
     return mNumeric->Flags;\r
   }\r


@@ -1417,10 +1424,10 @@ private:
   EFI_IFR_ONE_OF *mOneOf;\r
 \r
 public:\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
     mOneOf->Flags    = 0;\r
     gCurrentQuestion   = this;\r
     gCurrentMinMaxData = this;\r


@@ -1447,6 +1454,22 @@ public:
     return VFR_RETURN_SUCCESS;\r
   }\r
 \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
   VOID ShrinkBinSize (IN UINT16 Size) {\r
     //\r
     // Update the buffer size which is truly be used later.\r


@@ -1462,7 +1485,7 @@ public:
     //\r
     // Update the buffer pointer used by other class.\r
     //\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
     UpdateHeader (&mOneOf->Header);\r
     UpdateCIfrQuestionHeader(&mOneOf->Question);\r
     UpdateCIfrMinMaxStepData(&mOneOf->data);\r


@@ -1474,9 +1497,9 @@ private:
   EFI_IFR_STRING *mString;\r
 \r
 public:\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
     mString->Flags   = 0;\r
     mString->MinSize = 0;\r
     mString->MaxSize = 0;\r


@@ -1516,9 +1539,9 @@ private:
   EFI_IFR_PASSWORD *mPassword;\r
 \r
 public:\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
     mPassword->MinSize = 0;\r
     mPassword->MaxSize = 0;\r
     gCurrentQuestion   = this;\r


@@ -1542,9 +1565,9 @@ private:
   EFI_IFR_ORDERED_LIST *mOrderedList;\r
 \r
 public:\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
     mOrderedList->MaxContainers = 0;\r
     mOrderedList->Flags         = 0;\r
     gCurrentQuestion            = this;\r


@@ -1583,9 +1606,9 @@ private:
   EFI_IFR_TIME *mTime;\r
 \r
 public:\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
     mTime->Flags = 0;\r
   }\r
 \r


@@ -1622,31 +1645,21 @@ public:
 };\r
 \r
 class CIfrDisableIf : public CIfrObj, public CIfrOpHeader {\r
 };\r
 \r
 class CIfrDisableIf : public CIfrObj, public CIfrOpHeader {\r

-private:\r
-  EFI_IFR_DISABLE_IF *mDisableIf;\r
-\r

 public:\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
 };\r
 \r
 class CIfrSuppressIf : public CIfrObj, public CIfrOpHeader {\r

-private:\r
-  EFI_IFR_SUPPRESS_IF *mSuppressIf;\r
-\r

 public:\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
 };\r
 \r
 class CIfrGrayOutIf : public CIfrObj, public CIfrOpHeader {\r

-private:\r
-  EFI_IFR_GRAY_OUT_IF *mGrayOutIf;\r
-\r

 public:\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
 };\r
 \r
 class CIfrInconsistentIf : public CIfrObj, public CIfrOpHeader {\r


@@ -1654,8 +1667,8 @@ private:
   EFI_IFR_INCONSISTENT_IF *mInconsistentIf;\r
 \r
 public:\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
     mInconsistentIf->Error = EFI_STRING_ID_INVALID;\r
   }\r
 \r


@@ -1669,8 +1682,8 @@ private:
   EFI_IFR_WARNING_IF *mWarningIf;\r
 \r
 public:\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
     mWarningIf->Warning = EFI_STRING_ID_INVALID;\r
     mWarningIf->TimeOut = 0;\r
   }\r


@@ -1689,8 +1702,8 @@ private:
   EFI_IFR_NO_SUBMIT_IF *mNoSubmitIf;\r
 \r
 public:\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
     mNoSubmitIf->Error = EFI_STRING_ID_INVALID;\r
   }\r
 \r


@@ -1704,8 +1717,8 @@ private:
   EFI_IFR_REFRESH *mRefresh;\r
 \r
 public:\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
     mRefresh->RefreshInterval = 0;\r
   }\r
 \r


@@ -1719,8 +1732,8 @@ private:
   EFI_IFR_REFRESH_ID *mRefreshId;\r
 \r
 public:\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
     memset (&mRefreshId->RefreshEventGroupId, 0, sizeof (EFI_GUID));\r
   }\r
 \r


@@ -1734,8 +1747,8 @@ private:
   EFI_IFR_VARSTORE_DEVICE *mVarStoreDevice;\r
 \r
 public:\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
     mVarStoreDevice->DevicePath = EFI_STRING_ID_INVALID;\r
   }\r
 \r


@@ -1749,8 +1762,8 @@ private:
   EFI_IFR_ONE_OF_OPTION *mOneOfOption;\r
 \r
 public:\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
     mOneOfOption->Flags  = 0;\r
     mOneOfOption->Option = EFI_STRING_ID_INVALID;\r
     mOneOfOption->Type   = EFI_IFR_TYPE_OTHER;\r


@@ -1824,8 +1837,8 @@ private:
   EFI_IFR_GUID_CLASS *mClass;\r
 \r
 public:\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
     mClass->ExtendOpCode = EFI_IFR_EXTEND_OP_CLASS;\r
     mClass->Guid         = IfrTianoGuid;\r
     mClass->Class        = EFI_NON_DEVICE_CLASS;\r


@@ -1841,8 +1854,8 @@ private:
   EFI_IFR_GUID_SUBCLASS *mSubClass;\r
 \r
 public:\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
     mSubClass->ExtendOpCode = EFI_IFR_EXTEND_OP_SUBCLASS;\r
     mSubClass->Guid         = IfrTianoGuid;\r
     mSubClass->SubClass     = EFI_SETUP_APPLICATION_SUBCLASS;\r


@@ -1858,8 +1871,8 @@ private:
   EFI_IFR_GUID_LABEL *mLabel;\r
 \r
 public:\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
     mLabel->ExtendOpCode = EFI_IFR_EXTEND_OP_LABEL;\r
     mLabel->Guid         = IfrTianoGuid;\r
   }\r


@@ -1874,8 +1887,8 @@ private:
   EFI_IFR_GUID_BANNER *mBanner;\r
 \r
 public:\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
     mBanner->ExtendOpCode = EFI_IFR_EXTEND_OP_BANNER;\r
     mBanner->Guid         = IfrTianoGuid;\r
   }\r


@@ -1902,8 +1915,8 @@ public:
     IN EFI_QUESTION_ID QuestionId,\r
     IN EFI_IFR_TYPE_VALUE &OptionValue,\r
     IN EFI_QUESTION_ID KeyValue\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
     mOptionKey->ExtendOpCode = EFI_IFR_EXTEND_OP_OPTIONKEY;\r
     mOptionKey->Guid         = IfrFrameworkGuid;\r
     mOptionKey->QuestionId   = QuestionId;\r


@@ -1920,8 +1933,8 @@ public:
   CIfrVarEqName (\r
     IN EFI_QUESTION_ID QuestionId,\r
     IN EFI_STRING_ID   NameId\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
     mVarEqName->ExtendOpCode = EFI_IFR_EXTEND_OP_VAREQNAME;\r
     mVarEqName->Guid         = IfrFrameworkGuid;\r
     mVarEqName->QuestionId   = QuestionId;\r


@@ -1934,8 +1947,8 @@ private:
   EFI_IFR_GUID_TIMEOUT *mTimeout;\r
 \r
 public:\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
     mTimeout->ExtendOpCode = EFI_IFR_EXTEND_OP_TIMEOUT;\r
     mTimeout->Guid         = IfrTianoGuid;\r
     mTimeout->TimeOut      = Timeout;\r


@@ -1951,8 +1964,8 @@ private:
   EFI_IFR_GUID *mGuid;\r
 \r
 public:\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
     memset (&mGuid->Guid, 0, sizeof (EFI_GUID));\r
   }\r
 \r


@@ -1966,14 +1979,11 @@ public:
 };\r
 \r
 class CIfrDup : public CIfrObj, public CIfrOpHeader {\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
 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
     SetLineNo (LineNo);\r
   }\r
 };\r


@@ -1985,8 +1995,8 @@ private:
 public:\r
   CIfrEqIdId (\r
   IN UINT32 LineNo\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
     SetLineNo (LineNo);\r
     mEqIdId->QuestionId1 = EFI_QUESTION_ID_INVALID;\r
     mEqIdId->QuestionId2 = EFI_QUESTION_ID_INVALID;\r


@@ -2024,8 +2034,8 @@ private:
 public:\r
   CIfrEqIdVal (\r
   IN UINT32 LineNo\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
     SetLineNo (LineNo);\r
     mEqIdVal->QuestionId = EFI_QUESTION_ID_INVALID;\r
   }\r


@@ -2054,8 +2064,8 @@ private:
 public:\r
   CIfrEqIdList (\r
   IN UINT32 LineNo\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
     SetLineNo (LineNo);\r
     mEqIdVList->QuestionId   = EFI_QUESTION_ID_INVALID;\r
     mEqIdVList->ListLength   = 0;\r


@@ -2065,7 +2075,7 @@ public:
   VOID UpdateIfrBuffer ( \r
   ) {\r
     _EMIT_PENDING_OBJ();\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
     UpdateHeader (&mEqIdVList->Header);\r
   }\r
 \r


@@ -2105,8 +2115,8 @@ private:
 public:\r
   CIfrQuestionRef1 (\r
   IN UINT32 LineNo\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
     SetLineNo (LineNo);\r
     mQuestionRef1->QuestionId = EFI_QUESTION_ID_INVALID;\r
   }\r


@@ -2125,27 +2135,21 @@ public:
 };\r
 \r
 class CIfrQuestionRef2 : public CIfrObj, public CIfrOpHeader {\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
 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
     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
 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
     SetLineNo (LineNo);\r
   }\r
 };\r


@@ -2157,8 +2161,8 @@ private:
 public:\r
   CIfrQuestionRef3_2 (\r
   IN UINT32 LineNo\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
     SetLineNo (LineNo);\r
     mQuestionRef3_2->DevicePath = EFI_STRING_ID_INVALID;\r
   }\r


@@ -2175,8 +2179,8 @@ private:
 public:\r
   CIfrQuestionRef3_3 (\r
   IN UINT32 LineNo\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
     SetLineNo (LineNo);\r
     mQuestionRef3_3->DevicePath = EFI_STRING_ID_INVALID;\r
     memset (&mQuestionRef3_3->Guid, 0, sizeof (EFI_GUID));\r


@@ -2198,8 +2202,8 @@ private:
 public:\r
   CIfrRuleRef (\r
   IN UINT32 LineNo\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
     SetLineNo (LineNo);\r
     mRuleRef->RuleId = EFI_RULE_ID_INVALID;\r
   }\r


@@ -2216,8 +2220,8 @@ private:
 public:\r
   CIfrStringRef1 (\r
   IN UINT32 LineNo\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
     SetLineNo (LineNo);\r
     mStringRef1->StringId = EFI_STRING_ID_INVALID;\r
   }\r


@@ -2228,27 +2232,21 @@ public:
 };\r
 \r
 class CIfrStringRef2 : public CIfrObj, public CIfrOpHeader {\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
 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
     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
 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
     SetLineNo (LineNo);\r
   }\r
 };\r


@@ -2260,8 +2258,8 @@ private:
 public:\r
   CIfrSecurity (\r
   IN UINT32 LineNo\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
     SetLineNo (LineNo);\r
     memset (&mSecurity->Permissions, 0, sizeof (EFI_GUID));\r
   }\r


@@ -2278,8 +2276,8 @@ private:
 public:\r
   CIfrUint8 (\r
   IN UINT32 LineNo\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
     SetLineNo (LineNo);\r
   }\r
 \r


@@ -2295,8 +2293,8 @@ private:
 public:\r
   CIfrUint16 (\r
   IN UINT32 LineNo\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
     SetLineNo (LineNo);\r
   }\r
 \r


@@ -2312,8 +2310,8 @@ private:
 public:\r
   CIfrUint32 (\r
   IN UINT32 LineNo\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
     SetLineNo (LineNo);\r
   }\r
 \r


@@ -2329,8 +2327,8 @@ private:
 public:\r
   CIfrUint64 (\r
   IN UINT32 LineNo\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
     SetLineNo (LineNo);\r
   }\r
 \r


@@ -2340,144 +2338,111 @@ public:
 };\r
 \r
 class CIfrTrue : public CIfrObj, public CIfrOpHeader {\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
 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
     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
 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
     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
 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
     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
 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
     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
 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
     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
 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
     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
 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
     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
 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
     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
 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
     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
 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
     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
 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
     SetLineNo (LineNo);\r
   }\r
 };\r


@@ -2489,8 +2454,8 @@ private:
 public:\r
   CIfrToString (\r
   IN UINT32 LineNo\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
     SetLineNo (LineNo);\r
   }\r
 \r


@@ -2500,209 +2465,161 @@ public:
 };\r
 \r
 class CIfrToUint : public CIfrObj, public CIfrOpHeader {\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
 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
     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
 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
     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
 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
     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
 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
     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
 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
     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
 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
     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
 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
     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
 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
     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
 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
     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
 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
     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
 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
     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
 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
     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
 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
     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
 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
     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
 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
     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
 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
     SetLineNo (LineNo);\r
   }\r
 };\r


@@ -2715,113 +2632,89 @@ public:
   CIfrMatch2 (\r
   IN UINT32   LineNo,\r
   IN EFI_GUID *Guid\r
   CIfrMatch2 (\r
   IN UINT32   LineNo,\r
   IN EFI_GUID *Guid\r

-  ) : CIfrObj (EFI_IFR_MATCH2_OP, (CHAR8 **)&mMatch2),\r
-      CIfrOpHeader (EFI_IFR_MATCH2_OP, &mMatch2->Header) {\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
     SetLineNo (LineNo);\r
     memmove (&mMatch2->SyntaxType, Guid, sizeof (EFI_GUID));\r
   }\r
 };\r
 \r
 class CIfrMultiply : public CIfrObj, public CIfrOpHeader {\r

-private:\r
-  EFI_IFR_MULTIPLY *mMultiply;\r
-\r

 public:\r
   CIfrMultiply (\r
   IN UINT32 LineNo\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
     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
 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
     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
 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
     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
 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
     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
 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
     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
 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
     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
 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
     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
 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
     SetLineNo (LineNo);\r
   }\r
 };\r


@@ -2833,8 +2726,8 @@ private:
 public:\r
   CIfrFind (\r
   IN UINT32 LineNo\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
     SetLineNo (LineNo);\r
   }\r
 \r


@@ -2844,27 +2737,21 @@ public:
 };\r
 \r
 class CIfrMid : public CIfrObj, public CIfrOpHeader {\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
 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
     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
 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
     SetLineNo (LineNo);\r
   }\r
 };\r


@@ -2876,8 +2763,8 @@ private:
 public:\r
   CIfrSpan (\r
   IN UINT32 LineNo\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
     SetLineNo (LineNo);\r
     mSpan->Flags = EFI_IFR_FLAGS_FIRST_MATCHING;\r
   }\r