Sync all bug fixes between EDK1.04 and EDK1.06 into EdkCompatibilityPkg.

git-svn-id: https://edk2.svn.sourceforge.net/svnroot/edk2/trunk/edk2@11094 6f19259b-4bc3-4df7-8a09-765794883524

1 files changed, 166 insertions, 32 deletions

diff --git a/EdkCompatibilityPkg/Sample/Tools/Source/UefiVfrCompile/VfrFormPkg.h b/EdkCompatibilityPkg/Sample/Tools/Source/UefiVfrCompile/VfrFormPkg.h
index b890b27a25..c8e7d98756 100644
--- a/EdkCompatibilityPkg/Sample/Tools/Source/UefiVfrCompile/VfrFormPkg.h
+++ b/EdkCompatibilityPkg/Sample/Tools/Source/UefiVfrCompile/VfrFormPkg.h
@@ -11,7 +11,7 @@ WITHOUT WARRANTIES OR REPRESENTATIONS OF ANY KIND, EITHER EXPRESS OR IMPLIED.
 

 Module Name:

 

-VfrFormPkg.h

+  VfrFormPkg.h

 

 Abstract:

 

@@ -25,6 +25,8 @@ Abstract:
 #include "VfrError.h"

 #include "VfrUtilityLib.h"

 

+#define NO_QST_REFED "no question refered"

+

 /*

  * The functions below are used for flags setting

  */

@@ -75,9 +77,10 @@ struct SPendingAssign {
   UINT32                  mLen;

   ASSIGN_FLAG             mFlag;

   UINT32                  mLineNo;

+  INT8                    *mMsg;

   struct SPendingAssign   *mNext;

 

-  SPendingAssign (IN INT8 *, IN VOID *, IN UINT32, IN UINT32);

+  SPendingAssign (IN INT8 *, IN VOID *, IN UINT32, IN UINT32, IN INT8 *);

   ~SPendingAssign ();

 

   VOID   SetAddrAndLen (IN VOID *, IN UINT32);

@@ -126,7 +129,7 @@ public:
   EFI_VFR_RETURN_CODE GenCFile (IN INT8 *, IN FILE *);

 

 public:

-  EFI_VFR_RETURN_CODE AssignPending (IN INT8 *, IN VOID *, IN UINT32, IN UINT32);

+  EFI_VFR_RETURN_CODE AssignPending (IN INT8 *, IN VOID *, IN UINT32, IN UINT32, IN INT8 *Msg = NULL);

   VOID                DoPendingAssign (IN INT8 *, IN VOID *, IN UINT32);

   bool                HavePendingUnassigned (VOID);

   VOID                PendingAssignPrintAll (VOID);

@@ -368,48 +371,159 @@ public:
   }

 };

 

-static CIfrQuestionHeader *gCurrentQuestion = NULL;

-

 /*

  * The definition of CIfrMinMaxStepData

  */

 class CIfrMinMaxStepData {

 private:

   MINMAXSTEP_DATA *mMinMaxStepData;

+  BOOLEAN         ValueIsSet;

+  BOOLEAN         IsNumeric;

 

 public:

-  CIfrMinMaxStepData (MINMAXSTEP_DATA *DataAddr) : mMinMaxStepData (DataAddr) {

+  CIfrMinMaxStepData (MINMAXSTEP_DATA *DataAddr, BOOLEAN NumericOpcode=FALSE) : mMinMaxStepData (DataAddr) {

     mMinMaxStepData->u64.MinValue = 0;

     mMinMaxStepData->u64.MaxValue = 0;

     mMinMaxStepData->u64.Step     = 0;

+    ValueIsSet = FALSE;

+    IsNumeric = NumericOpcode;

   }

 

   VOID SetMinMaxStepData (IN UINT64 MinValue, IN UINT64 MaxValue, IN UINT64 Step) {

-    mMinMaxStepData->u64.MinValue = MinValue;

-    mMinMaxStepData->u64.MaxValue = MaxValue;

-    mMinMaxStepData->u64.Step     = Step;

+    if (!ValueIsSet) {

+      mMinMaxStepData->u64.MinValue = MinValue;

+      mMinMaxStepData->u64.MaxValue = MaxValue;

+      ValueIsSet = TRUE;

+    } else {

+      if (MinValue < mMinMaxStepData->u64.MinValue) {

+        mMinMaxStepData->u64.MinValue = MinValue;

+      }

+      if (MaxValue > mMinMaxStepData->u64.MaxValue) {

+        mMinMaxStepData->u64.MaxValue = MaxValue;

+      }

+    }

+    mMinMaxStepData->u64.Step = Step;

   }

 

   VOID SetMinMaxStepData (IN UINT32 MinValue, IN UINT32 MaxValue, IN UINT32 Step) {

-    mMinMaxStepData->u32.MinValue = MinValue;

-    mMinMaxStepData->u32.MaxValue = MaxValue;

-    mMinMaxStepData->u32.Step     = Step;

+    if (!ValueIsSet) {

+      mMinMaxStepData->u32.MinValue = MinValue;

+      mMinMaxStepData->u32.MaxValue = MaxValue;

+      ValueIsSet = TRUE;

+    } else {

+      if (MinValue < mMinMaxStepData->u32.MinValue) {

+        mMinMaxStepData->u32.MinValue = MinValue;

+      }

+      if (MaxValue > mMinMaxStepData->u32.MaxValue) {

+        mMinMaxStepData->u32.MaxValue = MaxValue;

+      }

+    }

+    mMinMaxStepData->u32.Step = Step;

   }

 

   VOID SetMinMaxStepData (IN UINT16 MinValue, IN UINT16 MaxValue, IN UINT16 Step) {

-    mMinMaxStepData->u16.MinValue = MinValue;

-    mMinMaxStepData->u16.MaxValue = MaxValue;

-    mMinMaxStepData->u16.Step     = Step;

+    if (!ValueIsSet) {

+      mMinMaxStepData->u16.MinValue = MinValue;

+      mMinMaxStepData->u16.MaxValue = MaxValue;

+      ValueIsSet = TRUE;

+    } else {

+      if (MinValue < mMinMaxStepData->u16.MinValue) {

+        mMinMaxStepData->u16.MinValue = MinValue;

+      }

+      if (MaxValue > mMinMaxStepData->u16.MaxValue) {

+        mMinMaxStepData->u16.MaxValue = MaxValue;

+      }

+    }

+    mMinMaxStepData->u16.Step = Step;

   }

 

   VOID SetMinMaxStepData (IN UINT8 MinValue, IN UINT8 MaxValue, IN UINT8 Step) {

-    mMinMaxStepData->u8.MinValue = MinValue;

-    mMinMaxStepData->u8.MaxValue = MaxValue;

-    mMinMaxStepData->u8.Step     = Step;

+    if (!ValueIsSet) {

+      mMinMaxStepData->u8.MinValue = MinValue;

+      mMinMaxStepData->u8.MaxValue = MaxValue;

+      ValueIsSet = TRUE;

+    } else {

+      if (MinValue < mMinMaxStepData->u8.MinValue) {

+        mMinMaxStepData->u8.MinValue = MinValue;

+      }

+      if (MaxValue > mMinMaxStepData->u8.MaxValue) {

+        mMinMaxStepData->u8.MaxValue = MaxValue;

+      }

+    }

+    mMinMaxStepData->u8.Step = Step;

+  }

+

+  UINT64 GetMinData (UINT8 VarType) {

+    UINT64 MinValue = 0;

+    switch (VarType) {

+    case EFI_IFR_TYPE_NUM_SIZE_64:

+      MinValue = mMinMaxStepData->u64.MinValue;

+      break;

+    case EFI_IFR_TYPE_NUM_SIZE_32:

+      MinValue = (UINT64) mMinMaxStepData->u32.MinValue;

+      break;

+    case EFI_IFR_TYPE_NUM_SIZE_16:

+      MinValue = (UINT64) mMinMaxStepData->u16.MinValue;

+      break;

+    case EFI_IFR_TYPE_NUM_SIZE_8:

+      MinValue = (UINT64) mMinMaxStepData->u8.MinValue;

+      break;

+    default:

+      break;

+    }

+    return MinValue;

+  }

+

+  UINT64 GetMaxData (UINT8 VarType) {

+    UINT64 MaxValue = 0;

+    switch (VarType) {

+    case EFI_IFR_TYPE_NUM_SIZE_64:

+      MaxValue = mMinMaxStepData->u64.MaxValue;

+      break;

+    case EFI_IFR_TYPE_NUM_SIZE_32:

+      MaxValue = (UINT64) mMinMaxStepData->u32.MaxValue;

+      break;

+    case EFI_IFR_TYPE_NUM_SIZE_16:

+      MaxValue = (UINT64) mMinMaxStepData->u16.MaxValue;

+      break;

+    case EFI_IFR_TYPE_NUM_SIZE_8:

+      MaxValue = (UINT64) mMinMaxStepData->u8.MaxValue;

+      break;

+    default:

+      break;

+    }

+    return MaxValue;

+  }

+

+  UINT64 GetStepData (UINT8 VarType) {

+    UINT64 MaxValue = 0;

+    switch (VarType) {

+    case EFI_IFR_TYPE_NUM_SIZE_64:

+      MaxValue = mMinMaxStepData->u64.Step;

+      break;

+    case EFI_IFR_TYPE_NUM_SIZE_32:

+      MaxValue = (UINT64) mMinMaxStepData->u32.Step;

+      break;

+    case EFI_IFR_TYPE_NUM_SIZE_16:

+      MaxValue = (UINT64) mMinMaxStepData->u16.Step;

+      break;

+    case EFI_IFR_TYPE_NUM_SIZE_8:

+      MaxValue = (UINT64) mMinMaxStepData->u8.Step;

+      break;

+    default:

+      break;

+    }

+    return MaxValue;

   }

 

+  BOOLEAN IsNumericOpcode () {

+    return IsNumeric;

+  }

 };

 

+static CIfrQuestionHeader *gCurrentQuestion  = NULL;

+static CIfrMinMaxStepData *gCurrentMinMaxData = NULL;

+

 /*

  * The definition of all of the UEFI IFR Objects

  */

@@ -418,10 +532,11 @@ private:
   EFI_IFR_FORM_SET *mFormSet;

 

 public:

-  CIfrFormSet () : CIfrObj (EFI_IFR_FORM_SET_OP, (CHAR8 **)&mFormSet),

-                   CIfrOpHeader (EFI_IFR_FORM_SET_OP, &mFormSet->Header) {

+  CIfrFormSet (UINT8 Size) : CIfrObj (EFI_IFR_FORM_SET_OP, (CHAR8 **)&mFormSet, Size),

+                   CIfrOpHeader (EFI_IFR_FORM_SET_OP, &mFormSet->Header, Size) {

     mFormSet->Help         = EFI_STRING_ID_INVALID;

     mFormSet->FormSetTitle = EFI_STRING_ID_INVALID;

+    mFormSet->Flags        = 0;

     memset (&mFormSet->Guid, 0, sizeof (EFI_GUID));

   }

 

@@ -436,6 +551,17 @@ public:
   VOID SetHelp (IN EFI_STRING_ID Help) {

     mFormSet->Help = Help;

   }

+

+  VOID SetClassGuid (IN EFI_GUID *Guid) {

+    if (mFormSet->Flags > 0 && ExpendObjBin(sizeof(EFI_GUID))) {

+      IncLength (sizeof (EFI_GUID));

+    }

+    memcpy (&(mFormSet->ClassGuid[mFormSet->Flags++]), Guid, sizeof (EFI_GUID));

+  }

+

+  UINT8 GetFlags() {

+    return mFormSet->Flags;

+  }

 };

 

 class CIfrEnd : public CIfrObj, public CIfrOpHeader {

@@ -817,7 +943,7 @@ private:
 public:

   CIfrResetButton () : CIfrObj (EFI_IFR_RESET_BUTTON_OP, (CHAR8 **)&mResetButton),

                        CIfrOpHeader (EFI_IFR_RESET_BUTTON_OP, &mResetButton->Header), 

-					   CIfrStatementHeader (&mResetButton->Question.Header) {

+					   CIfrStatementHeader (&mResetButton->Statement) {

     mResetButton->DefaultId = EFI_HII_DEFAULT_CLASS_STANDARD;

   }

 

@@ -834,7 +960,7 @@ public:
   CIfrCheckBox () : CIfrObj (EFI_IFR_CHECKBOX_OP, (CHAR8 **)&mCheckBox),

                      CIfrOpHeader (EFI_IFR_CHECKBOX_OP, &mCheckBox->Header), 

                      CIfrQuestionHeader (&mCheckBox->Question) {

-    mCheckBox->Flags = EFI_IFR_CHECKBOX_DEFAULT;

+    mCheckBox->Flags = 0;

     gCurrentQuestion = this;

   }

 

@@ -860,6 +986,10 @@ public:
 

     return _FLAGS_ZERO (LFlags) ? VFR_RETURN_SUCCESS : VFR_RETURN_FLAGS_UNSUPPORTED;

   }

+

+  UINT8 GetFlags (VOID) {

+    return mCheckBox->Flags;

+  }

 };

 

 class CIfrAction : public CIfrObj, public CIfrOpHeader, public CIfrQuestionHeader {

@@ -929,13 +1059,15 @@ public:
   CIfrNumeric () : CIfrObj (EFI_IFR_NUMERIC_OP, (CHAR8 **)&mNumeric),

                    CIfrOpHeader (EFI_IFR_NUMERIC_OP, &mNumeric->Header),

                    CIfrQuestionHeader (&mNumeric->Question),

-                   CIfrMinMaxStepData (&mNumeric->data) {

+                   CIfrMinMaxStepData (&mNumeric->data, TRUE) {

     mNumeric->Flags  = EFI_IFR_NUMERIC_SIZE_1 | EFI_IFR_DISPLAY_UINT_DEC;

-    gCurrentQuestion = this;

+    gCurrentQuestion   = this;

+    gCurrentMinMaxData = this;

   }

 

   ~CIfrNumeric () {

-    gCurrentQuestion = NULL;

+    gCurrentQuestion   = NULL;

+    gCurrentMinMaxData = NULL;

   }

 

   EFI_VFR_RETURN_CODE SetFlags (IN UINT8 HFlags, IN UINT8 LFlags) {

@@ -965,11 +1097,13 @@ public:
                  CIfrQuestionHeader (&mOneOf->Question),

                  CIfrMinMaxStepData (&mOneOf->data) {

     mOneOf->Flags    = 0;

-    gCurrentQuestion = this;

+    gCurrentQuestion   = this;

+    gCurrentMinMaxData = this;

   }

 

   ~CIfrOneOf () {

-    gCurrentQuestion = NULL;

+    gCurrentQuestion   = NULL;

+    gCurrentMinMaxData = NULL;

   }

 

   EFI_VFR_RETURN_CODE SetFlags (IN UINT8 HFlags, IN UINT8 LFlags) {

@@ -1428,7 +1562,7 @@ public:
     if (QuestionId != EFI_QUESTION_ID_INVALID) {

       mEqIdId->QuestionId1 = QuestionId;

     } else {

-      gCFormPkg.AssignPending (VarIdStr, (VOID *)(&mEqIdId->QuestionId1), sizeof (EFI_QUESTION_ID), LineNo);

+      gCFormPkg.AssignPending (VarIdStr, (VOID *)(&mEqIdId->QuestionId1), sizeof (EFI_QUESTION_ID), LineNo, NO_QST_REFED);

     }

   }

 

@@ -1440,7 +1574,7 @@ public:
     if (QuestionId != EFI_QUESTION_ID_INVALID) {

       mEqIdId->QuestionId2 = QuestionId;

     } else {

-      gCFormPkg.AssignPending (VarIdStr, (VOID *)(&mEqIdId->QuestionId2), sizeof (EFI_QUESTION_ID), LineNo);

+      gCFormPkg.AssignPending (VarIdStr, (VOID *)(&mEqIdId->QuestionId2), sizeof (EFI_QUESTION_ID), LineNo, NO_QST_REFED);

     }

   }

 };

@@ -1466,7 +1600,7 @@ public:
     if (QuestionId != EFI_QUESTION_ID_INVALID) {

       mEqIdVal->QuestionId = QuestionId;

     } else {

-      gCFormPkg.AssignPending (VarIdStr, (VOID *)(&mEqIdVal->QuestionId), sizeof (EFI_QUESTION_ID), LineNo);

+      gCFormPkg.AssignPending (VarIdStr, (VOID *)(&mEqIdVal->QuestionId), sizeof (EFI_QUESTION_ID), LineNo, NO_QST_REFED);

     }

   }

 

@@ -1498,7 +1632,7 @@ public:
     if (QuestionId != EFI_QUESTION_ID_INVALID) {

       mEqIdVList->QuestionId = QuestionId;

     } else {

-      gCFormPkg.AssignPending (VarIdStr, (VOID *)(&mEqIdVList->QuestionId), sizeof (EFI_QUESTION_ID), LineNo);

+      gCFormPkg.AssignPending (VarIdStr, (VOID *)(&mEqIdVList->QuestionId), sizeof (EFI_QUESTION_ID), LineNo, NO_QST_REFED);

     }

   }

 

@@ -1540,7 +1674,7 @@ public:
     if (QuestionId != EFI_QUESTION_ID_INVALID) {

       mQuestionRef1->QuestionId = QuestionId;

     } else {

-      gCFormPkg.AssignPending (VarIdStr, (VOID *)(&mQuestionRef1->QuestionId), sizeof (EFI_QUESTION_ID), LineNo);

+      gCFormPkg.AssignPending (VarIdStr, (VOID *)(&mQuestionRef1->QuestionId), sizeof (EFI_QUESTION_ID), LineNo, NO_QST_REFED);

     }

   }

 };