BaseTools: Eot - fix variable names

1) currently a couple classes use m instead of self (including some mixed
functions that should have previously failed).
2) deleted some blank lines.

Cc: Yonghong Zhu <yonghong.zhu@intel.com>
Cc: Liming Gao <liming.gao@intel.com>
Contributed-under: TianoCore Contribution Agreement 1.1
Signed-off-by: Jaben Carsey <jaben.carsey@intel.com>
Reviewed-by: Yonghong Zhu <yonghong.zhu@intel.com>

diff --git a/BaseTools/Source/Python/Eot/Eot.py b/BaseTools/Source/Python/Eot/Eot.py
index 6fb882642bff94022aa37dc2204a611706926792..ce83da14957b520df806213ec4363ea32fbf46fd 100644 (file)
--- a/BaseTools/Source/Python/Eot/Eot.py
+++ b/BaseTools/Source/Python/Eot/Eot.py
@@ -123,49 +123,49 @@ class CompressedImage(Image):
     _ORIG_SIZE_     = struct.Struct("1I")\r
     _CMPRS_TYPE_    = struct.Struct("4x 1B")\r
 \r
     _ORIG_SIZE_     = struct.Struct("1I")\r
     _CMPRS_TYPE_    = struct.Struct("4x 1B")\r
 \r

-    def __init__(m, CompressedData=None, CompressionType=None, UncompressedLength=None):\r
-        Image.__init__(m)\r
+    def __init__(self, CompressedData=None, CompressionType=None, UncompressedLength=None):\r
+        Image.__init__(self)\r

         if UncompressedLength is not None:\r
         if UncompressedLength is not None:\r

-            m.UncompressedLength = UncompressedLength\r
+            self.UncompressedLength = UncompressedLength\r

         if CompressionType is not None:\r
         if CompressionType is not None:\r

-            m.CompressionType = CompressionType\r
+            self.CompressionType = CompressionType\r

         if CompressedData is not None:\r
         if CompressedData is not None:\r

-            m.Data = CompressedData\r
+            self.Data = CompressedData\r

 \r
 \r

-    def __str__(m):\r
+    def __str__(self):\r

         global gIndention\r
         global gIndention\r

-        S = "algorithm=%s uncompressed=%x" % (m.CompressionType, m.UncompressedLength)\r
-        for Sec in m.Sections:\r
+        S = "algorithm=%s uncompressed=%x" % (self.CompressionType, self.UncompressedLength)\r
+        for Sec in self.Sections:\r

             S += '\n' + str(Sec)\r
 \r
         return S\r
 \r
             S += '\n' + str(Sec)\r
 \r
         return S\r
 \r

-    def _SetOriginalSize(m, Size):\r
-        m.SetField(m._ORIG_SIZE_, 0, Size)\r
+    def _SetOriginalSize(self, Size):\r
+        self.SetField(self._ORIG_SIZE_, 0, Size)\r

 \r
 \r

-    def _GetOriginalSize(m):\r
-        return m.GetField(m._ORIG_SIZE_)[0]\r
+    def _GetOriginalSize(self):\r
+        return self.GetField(self._ORIG_SIZE_)[0]\r

 \r
 \r

-    def _SetCompressionType(m, Type):\r
-        m.SetField(m._CMPRS_TYPE_, 0, Type)\r
+    def _SetCompressionType(self, Type):\r
+        self.SetField(self._CMPRS_TYPE_, 0, Type)\r

 \r
 \r

-    def _GetCompressionType(m):\r
-        return m.GetField(m._CMPRS_TYPE_)[0]\r
+    def _GetCompressionType(self):\r
+        return self.GetField(self._CMPRS_TYPE_)[0]\r

 \r
 \r

-    def _GetSections(m):\r
+    def _GetSections(self):\r

         try:\r
             from . import EfiCompressor\r
             TmpData = EfiCompressor.FrameworkDecompress(\r
         try:\r
             from . import EfiCompressor\r
             TmpData = EfiCompressor.FrameworkDecompress(\r

-                                        m[m._HEADER_SIZE_:],\r
-                                        len(m) - m._HEADER_SIZE_\r
+                                        self[self._HEADER_SIZE_:],\r
+                                        len(self) - self._HEADER_SIZE_\r

                                         )\r
             DecData = array('B')\r
             DecData.fromstring(TmpData)\r
         except:\r
             from . import EfiCompressor\r
             TmpData = EfiCompressor.UefiDecompress(\r
                                         )\r
             DecData = array('B')\r
             DecData.fromstring(TmpData)\r
         except:\r
             from . import EfiCompressor\r
             TmpData = EfiCompressor.UefiDecompress(\r

-                                        m[m._HEADER_SIZE_:],\r
-                                        len(m) - m._HEADER_SIZE_\r
+                                        self[self._HEADER_SIZE_:],\r
+                                        len(self) - self._HEADER_SIZE_\r

                                         )\r
             DecData = array('B')\r
             DecData.fromstring(TmpData)\r
                                         )\r
             DecData = array('B')\r
             DecData.fromstring(TmpData)\r


@@ -195,20 +195,20 @@ class Ui(Image):
     _HEADER_ = struct.Struct("")\r
     _HEADER_SIZE_ = 0\r
 \r
     _HEADER_ = struct.Struct("")\r
     _HEADER_SIZE_ = 0\r
 \r

-    def __init__(m):\r
-        Image.__init__(m)\r
+    def __init__(self):\r
+        Image.__init__(self)\r

 \r
 \r

-    def __str__(m):\r
-        return m.String\r
+    def __str__(self):\r
+        return self.String\r

 \r
 \r

-    def _Unpack(m):\r
+    def _Unpack(self):\r

         # keep header in this Image object\r
         # keep header in this Image object\r

-        m.empty()\r
-        m.extend(m._BUF_[m._OFF_ : m._OFF_ + m._LEN_])\r
-        return len(m)\r
+        self.empty()\r
+        self.extend(self._BUF_[self._OFF_ : self._OFF_ + self._LEN_])\r
+        return len(self)\r

 \r
 \r

-    def _GetUiString(m):\r
-        return codecs.utf_16_decode(m[0:-2].tostring())[0]\r
+    def _GetUiString(self):\r
+        return codecs.utf_16_decode(self[0:-2].tostring())[0]\r

 \r
     String = property(_GetUiString)\r
 \r
 \r
     String = property(_GetUiString)\r
 \r


@@ -250,18 +250,18 @@ class Depex(Image):
         0x09    :   _OPCODE_,   #"SOR"\r
     }\r
 \r
         0x09    :   _OPCODE_,   #"SOR"\r
     }\r
 \r

-    def __init__(m):\r
-        Image.__init__(m)\r
-        m._ExprList = []\r
+    def __init__(self):\r
+        Image.__init__(self)\r
+        self._ExprList = []\r

 \r
 \r

-    def __str__(m):\r
+    def __str__(self):\r

         global gIndention\r
         gIndention += 4\r
         Indention = ' ' * gIndention\r
         S = '\n'\r
         global gIndention\r
         gIndention += 4\r
         Indention = ' ' * gIndention\r
         S = '\n'\r

-        for T in m.Expression:\r
-            if T in m._OPCODE_STRING_:\r
-                S += Indention + m._OPCODE_STRING_[T]\r
+        for T in self.Expression:\r
+            if T in self._OPCODE_STRING_:\r
+                S += Indention + self._OPCODE_STRING_[T]\r

                 if T not in [0x00, 0x01, 0x02]:\r
                     S += '\n'\r
             else:\r
                 if T not in [0x00, 0x01, 0x02]:\r
                     S += '\n'\r
             else:\r


@@ -269,31 +269,31 @@ class Depex(Image):
         gIndention -= 4\r
         return S\r
 \r
         gIndention -= 4\r
         return S\r
 \r

-    def _Unpack(m):\r
+    def _Unpack(self):\r

         # keep header in this Image object\r
         # keep header in this Image object\r

-        m.empty()\r
-        m.extend(m._BUF_[m._OFF_ : m._OFF_ + m._LEN_])\r
-        return len(m)\r
+        self.empty()\r
+        self.extend(self._BUF_[self._OFF_ : self._OFF_ + self._LEN_])\r
+        return len(self)\r

 \r
 \r

-    def _GetExpression(m):\r
-        if m._ExprList == []:\r
+    def _GetExpression(self):\r
+        if self._ExprList == []:\r

             Offset = 0\r
             Offset = 0\r

-            CurrentData = m._OPCODE_\r
-            while Offset < len(m):\r
-                Token = CurrentData.unpack_from(m, Offset)\r
+            CurrentData = self._OPCODE_\r
+            while Offset < len(self):\r
+                Token = CurrentData.unpack_from(self, Offset)\r

                 Offset += CurrentData.size\r
                 if len(Token) == 1:\r
                     Token = Token[0]\r
                 Offset += CurrentData.size\r
                 if len(Token) == 1:\r
                     Token = Token[0]\r

-                    if Token in m._NEXT_:\r
-                        CurrentData = m._NEXT_[Token]\r
+                    if Token in self._NEXT_:\r
+                        CurrentData = self._NEXT_[Token]\r

                     else:\r
                     else:\r

-                        CurrentData = m._GUID_\r
+                        CurrentData = self._GUID_\r

                 else:\r
                 else:\r

-                    CurrentData = m._OPCODE_\r
-                m._ExprList.append(Token)\r
+                    CurrentData = self._OPCODE_\r
+                self._ExprList.append(Token)\r

                 if CurrentData is None:\r
                     break\r
                 if CurrentData is None:\r
                     break\r

-        return m._ExprList\r
+        return self._ExprList\r

 \r
     Expression = property(_GetExpression)\r
 \r
 \r
     Expression = property(_GetExpression)\r
 \r


@@ -326,9 +326,7 @@ class FirmwareVolume(Image):
     def CheckArchProtocol(self):\r
         for Item in EotGlobalData.gArchProtocolGuids:\r
             if Item.lower() not in EotGlobalData.gProtocolList:\r
     def CheckArchProtocol(self):\r
         for Item in EotGlobalData.gArchProtocolGuids:\r
             if Item.lower() not in EotGlobalData.gProtocolList:\r

-\r

                 return False\r
                 return False\r

-\r

         return True\r
 \r
     def ParseDepex(self, Depex, Type):\r
         return True\r
 \r
     def ParseDepex(self, Depex, Type):\r


@@ -441,7 +439,6 @@ class FirmwareVolume(Image):
                             if GuidString in self.UnDispatchedFfsDict:\r
                                 self.OrderedFfsDict[GuidString] = self.UnDispatchedFfsDict.pop(GuidString)\r
                                 self.LoadPpi(Db, GuidString)\r
                             if GuidString in self.UnDispatchedFfsDict:\r
                                 self.OrderedFfsDict[GuidString] = self.UnDispatchedFfsDict.pop(GuidString)\r
                                 self.LoadPpi(Db, GuidString)\r

-\r

         self.DisPatchPei(Db)\r
 \r
         # Parse DXE then\r
         self.DisPatchPei(Db)\r
 \r
         # Parse DXE then\r


@@ -463,7 +460,6 @@ class FirmwareVolume(Image):
                             if GuidString in self.UnDispatchedFfsDict:\r
                                 self.OrderedFfsDict[GuidString] = self.UnDispatchedFfsDict.pop(GuidString)\r
                                 self.LoadProtocol(Db, GuidString)\r
                             if GuidString in self.UnDispatchedFfsDict:\r
                                 self.OrderedFfsDict[GuidString] = self.UnDispatchedFfsDict.pop(GuidString)\r
                                 self.LoadProtocol(Db, GuidString)\r

-\r

         self.DisPatchDxe(Db)\r
 \r
     def LoadProtocol(self, Db, ModuleGuid):\r
         self.DisPatchDxe(Db)\r
 \r
     def LoadProtocol(self, Db, ModuleGuid):\r


@@ -564,7 +560,6 @@ class FirmwareVolume(Image):
             RecordSet = Db.TblReport.Exec(SqlCommand)\r
             if RecordSet != []:\r
                 FfsName = RecordSet[0][0]\r
             RecordSet = Db.TblReport.Exec(SqlCommand)\r
             if RecordSet != []:\r
                 FfsName = RecordSet[0][0]\r

-\r

         if IsInstalled:\r
             self.DisPatchDxe(Db)\r
 \r
         if IsInstalled:\r
             self.DisPatchDxe(Db)\r
 \r


@@ -608,7 +603,6 @@ class FirmwareVolume(Image):
         if IsInstalled:\r
             self.DisPatchPei(Db)\r
 \r
         if IsInstalled:\r
             self.DisPatchPei(Db)\r
 \r

-\r

     def __str__(self):\r
         global gIndention\r
         gIndention += 4\r
     def __str__(self):\r
         global gIndention\r
         gIndention += 4\r


@@ -690,69 +684,69 @@ class GuidDefinedImage(Image):
     TIANO_COMPRESS_GUID = 'A31280AD-481E-41B6-95E8-127F4C984779'\r
     LZMA_COMPRESS_GUID  = 'EE4E5898-3914-4259-9D6E-DC7BD79403CF'\r
 \r
     TIANO_COMPRESS_GUID = 'A31280AD-481E-41B6-95E8-127F4C984779'\r
     LZMA_COMPRESS_GUID  = 'EE4E5898-3914-4259-9D6E-DC7BD79403CF'\r
 \r

-    def __init__(m, SectionDefinitionGuid=None, DataOffset=None, Attributes=None, Data=None):\r
-        Image.__init__(m)\r
+    def __init__(self, SectionDefinitionGuid=None, DataOffset=None, Attributes=None, Data=None):\r
+        Image.__init__(self)\r

         if SectionDefinitionGuid is not None:\r
         if SectionDefinitionGuid is not None:\r

-            m.SectionDefinitionGuid = SectionDefinitionGuid\r
+            self.SectionDefinitionGuid = SectionDefinitionGuid\r

         if DataOffset is not None:\r
         if DataOffset is not None:\r

-            m.DataOffset = DataOffset\r
+            self.DataOffset = DataOffset\r

         if Attributes is not None:\r
         if Attributes is not None:\r

-            m.Attributes = Attributes\r
+            self.Attributes = Attributes\r

         if Data is not None:\r
         if Data is not None:\r

-            m.Data = Data\r
+            self.Data = Data\r

 \r
 \r

-    def __str__(m):\r
-        S = "guid=%s" % (gGuidStringFormat % m.SectionDefinitionGuid)\r
-        for Sec in m.Sections:\r
+    def __str__(self):\r
+        S = "guid=%s" % (gGuidStringFormat % self.SectionDefinitionGuid)\r
+        for Sec in self.Sections:\r

             S += "\n" + str(Sec)\r
         return S\r
 \r
             S += "\n" + str(Sec)\r
         return S\r
 \r

-    def _Unpack(m):\r
+    def _Unpack(self):\r

         # keep header in this Image object\r
         # keep header in this Image object\r

-        m.empty()\r
-        m.extend(m._BUF_[m._OFF_ : m._OFF_ + m._LEN_])\r
-        return len(m)\r
+        self.empty()\r
+        self.extend(self._BUF_[self._OFF_ : self._OFF_ + self._LEN_])\r
+        return len(self)\r

 \r
 \r

-    def _SetAttribute(m, Attribute):\r
-        m.SetField(m._ATTR_, 0, Attribute)\r
+    def _SetAttribute(self, Attribute):\r
+        self.SetField(self._ATTR_, 0, Attribute)\r

 \r
 \r

-    def _GetAttribute(m):\r
-        return m.GetField(m._ATTR_)[0]\r
+    def _GetAttribute(self):\r
+        return self.GetField(self._ATTR_)[0]\r

 \r
 \r

-    def _SetGuid(m, Guid):\r
-        m.SetField(m._GUID_, 0, Guid)\r
+    def _SetGuid(self, Guid):\r
+        self.SetField(self._GUID_, 0, Guid)\r

 \r
 \r

-    def _GetGuid(m):\r
-        return m.GetField(m._GUID_)\r
+    def _GetGuid(self):\r
+        return self.GetField(self._GUID_)\r

 \r
 \r

-    def _SetDataOffset(m, Offset):\r
-        m.SetField(m._DATA_OFFSET_, 0, Offset)\r
+    def _SetDataOffset(self, Offset):\r
+        self.SetField(self._DATA_OFFSET_, 0, Offset)\r

 \r
 \r

-    def _GetDataOffset(m):\r
-        return m.GetField(m._DATA_OFFSET_)[0]\r
+    def _GetDataOffset(self):\r
+        return self.GetField(self._DATA_OFFSET_)[0]\r

 \r
 \r

-    def _GetSections(m):\r
+    def _GetSections(self):\r

         SectionList = []\r
         SectionList = []\r

-        Guid = gGuidStringFormat % m.SectionDefinitionGuid\r
-        if Guid == m.CRC32_GUID:\r
+        Guid = gGuidStringFormat % self.SectionDefinitionGuid\r
+        if Guid == self.CRC32_GUID:\r

             # skip the CRC32 value, we don't do CRC32 verification here\r
             # skip the CRC32 value, we don't do CRC32 verification here\r

-            Offset = m.DataOffset - 4\r
-            while Offset < len(m):\r
+            Offset = self.DataOffset - 4\r
+            while Offset < len(self):\r

                 Sec = Section()\r
                 try:\r
                 Sec = Section()\r
                 try:\r

-                    Sec.frombuffer(m, Offset)\r
+                    Sec.frombuffer(self, Offset)\r

                     Offset += Sec.Size\r
                     # the section is aligned to 4-byte boundary\r
                     Offset = (Offset + 3) & (~3)\r
                 except:\r
                     break\r
                 SectionList.append(Sec)\r
                     Offset += Sec.Size\r
                     # the section is aligned to 4-byte boundary\r
                     Offset = (Offset + 3) & (~3)\r
                 except:\r
                     break\r
                 SectionList.append(Sec)\r

-        elif Guid == m.TIANO_COMPRESS_GUID:\r
+        elif Guid == self.TIANO_COMPRESS_GUID:\r

             try:\r
                 from . import EfiCompressor\r
                 # skip the header\r
             try:\r
                 from . import EfiCompressor\r
                 # skip the header\r

-                Offset = m.DataOffset - 4\r
-                TmpData = EfiCompressor.FrameworkDecompress(m[Offset:], len(m)-Offset)\r
+                Offset = self.DataOffset - 4\r
+                TmpData = EfiCompressor.FrameworkDecompress(self[Offset:], len(self)-Offset)\r

                 DecData = array('B')\r
                 DecData.fromstring(TmpData)\r
                 Offset = 0\r
                 DecData = array('B')\r
                 DecData.fromstring(TmpData)\r
                 Offset = 0\r


@@ -768,12 +762,12 @@ class GuidDefinedImage(Image):
                     SectionList.append(Sec)\r
             except:\r
                 pass\r
                     SectionList.append(Sec)\r
             except:\r
                 pass\r

-        elif Guid == m.LZMA_COMPRESS_GUID:\r
+        elif Guid == self.LZMA_COMPRESS_GUID:\r

             try:\r
                 from . import LzmaCompressor\r
                 # skip the header\r
             try:\r
                 from . import LzmaCompressor\r
                 # skip the header\r

-                Offset = m.DataOffset - 4\r
-                TmpData = LzmaCompressor.LzmaDecompress(m[Offset:], len(m)-Offset)\r
+                Offset = self.DataOffset - 4\r
+                TmpData = LzmaCompressor.LzmaDecompress(self[Offset:], len(self)-Offset)\r

                 DecData = array('B')\r
                 DecData.fromstring(TmpData)\r
                 Offset = 0\r
                 DecData = array('B')\r
                 DecData.fromstring(TmpData)\r
                 Offset = 0\r


@@ -835,90 +829,89 @@ class Section(Image):
 \r
     # SubTypeGuid\r
     # _FREE_FORM_SUBTYPE_GUID_HEADER_ = struct.Struct("1I2H8B")\r
 \r
     # SubTypeGuid\r
     # _FREE_FORM_SUBTYPE_GUID_HEADER_ = struct.Struct("1I2H8B")\r

-\r

     _SIZE_          = struct.Struct("3B")\r
     _TYPE_          = struct.Struct("3x 1B")\r
 \r
     _SIZE_          = struct.Struct("3B")\r
     _TYPE_          = struct.Struct("3x 1B")\r
 \r

-    def __init__(m, Type=None, Size=None):\r
-        Image.__init__(m)\r
-        m._Alignment = 1\r
+    def __init__(self, Type=None, Size=None):\r
+        Image.__init__(self)\r
+        self._Alignment = 1\r

         if Type is not None:\r
         if Type is not None:\r

-            m.Type = Type\r
+            self.Type = Type\r

         if Size is not None:\r
         if Size is not None:\r

-            m.Size = Size\r
+            self.Size = Size\r

 \r
 \r

-    def __str__(m):\r
+    def __str__(self):\r

         global gIndention\r
         gIndention += 4\r
         SectionInfo = ' ' * gIndention\r
         global gIndention\r
         gIndention += 4\r
         SectionInfo = ' ' * gIndention\r

-        if m.Type in m._TypeName:\r
-            SectionInfo += "[SECTION:%s] offset=%x size=%x" % (m._TypeName[m.Type], m._OFF_, m.Size)\r
+        if self.Type in self._TypeName:\r
+            SectionInfo += "[SECTION:%s] offset=%x size=%x" % (self._TypeName[self.Type], self._OFF_, self.Size)\r

         else:\r
         else:\r

-            SectionInfo += "[SECTION:%x<unknown>] offset=%x size=%x " % (m.Type, m._OFF_, m.Size)\r
-        for Offset in m._SubImages:\r
-            SectionInfo += ", " + str(m._SubImages[Offset])\r
+            SectionInfo += "[SECTION:%x<unknown>] offset=%x size=%x " % (self.Type, self._OFF_, self.Size)\r
+        for Offset in self._SubImages:\r
+            SectionInfo += ", " + str(self._SubImages[Offset])\r

         gIndention -= 4\r
         return SectionInfo\r
 \r
         gIndention -= 4\r
         return SectionInfo\r
 \r

-    def _Unpack(m):\r
-        m.empty()\r
-        Type, = m._TYPE_.unpack_from(m._BUF_, m._OFF_)\r
-        Size1, Size2, Size3 = m._SIZE_.unpack_from(m._BUF_, m._OFF_)\r
+    def _Unpack(self):\r
+        self.empty()\r
+        Type, = self._TYPE_.unpack_from(self._BUF_, self._OFF_)\r
+        Size1, Size2, Size3 = self._SIZE_.unpack_from(self._BUF_, self._OFF_)\r

         Size = Size1 + (Size2 << 8) + (Size3 << 16)\r
 \r
         Size = Size1 + (Size2 << 8) + (Size3 << 16)\r
 \r

-        if Type not in m._SectionSubImages:\r
+        if Type not in self._SectionSubImages:\r

             # no need to extract sub-image, keep all in this Image object\r
             # no need to extract sub-image, keep all in this Image object\r

-            m.extend(m._BUF_[m._OFF_ : m._OFF_ + Size])\r
+            self.extend(self._BUF_[self._OFF_ : self._OFF_ + Size])\r

         else:\r
             # keep header in this Image object\r
         else:\r
             # keep header in this Image object\r

-            m.extend(m._BUF_[m._OFF_ : m._OFF_ + m._HEADER_SIZE_])\r
+            self.extend(self._BUF_[self._OFF_ : self._OFF_ + self._HEADER_SIZE_])\r

             #\r
             # use new Image object to represent payload, which may be another kind\r
             # of image such as PE32\r
             #\r
             #\r
             # use new Image object to represent payload, which may be another kind\r
             # of image such as PE32\r
             #\r

-            PayloadOffset = m._HEADER_SIZE_\r
-            PayloadLen = m.Size - m._HEADER_SIZE_\r
-            Payload = m._SectionSubImages[m.Type]()\r
-            Payload.frombuffer(m._BUF_, m._OFF_ + m._HEADER_SIZE_, PayloadLen)\r
-            m._SubImages[PayloadOffset] = Payload\r
+            PayloadOffset = self._HEADER_SIZE_\r
+            PayloadLen = self.Size - self._HEADER_SIZE_\r
+            Payload = self._SectionSubImages[self.Type]()\r
+            Payload.frombuffer(self._BUF_, self._OFF_ + self._HEADER_SIZE_, PayloadLen)\r
+            self._SubImages[PayloadOffset] = Payload\r

 \r
         return Size\r
 \r
 \r
         return Size\r
 \r

-    def _SetSize(m, Size):\r
+    def _SetSize(self, Size):\r

         Size1 = Size & 0xFF\r
         Size2 = (Size & 0xFF00) >> 8\r
         Size3 = (Size & 0xFF0000) >> 16\r
         Size1 = Size & 0xFF\r
         Size2 = (Size & 0xFF00) >> 8\r
         Size3 = (Size & 0xFF0000) >> 16\r

-        m.SetField(m._SIZE_, 0, Size1, Size2, Size3)\r
+        self.SetField(self._SIZE_, 0, Size1, Size2, Size3)\r

 \r
 \r

-    def _GetSize(m):\r
-        Size1, Size2, Size3 = m.GetField(m._SIZE_)\r
+    def _GetSize(self):\r
+        Size1, Size2, Size3 = self.GetField(self._SIZE_)\r

         return Size1 + (Size2 << 8) + (Size3 << 16)\r
 \r
         return Size1 + (Size2 << 8) + (Size3 << 16)\r
 \r

-    def _SetType(m, Type):\r
-        m.SetField(m._TYPE_, 0, Type)\r
+    def _SetType(self, Type):\r
+        self.SetField(self._TYPE_, 0, Type)\r

 \r
 \r

-    def _GetType(m):\r
-        return m.GetField(m._TYPE_)[0]\r
+    def _GetType(self):\r
+        return self.GetField(self._TYPE_)[0]\r

 \r
 \r

-    def _GetAlignment(m):\r
-        return m._Alignment\r
+    def _GetAlignment(self):\r
+        return self._Alignment\r

 \r
 \r

-    def _SetAlignment(m, Alignment):\r
-        m._Alignment = Alignment\r
+    def _SetAlignment(self, Alignment):\r
+        self._Alignment = Alignment\r

         AlignmentMask = Alignment - 1\r
         # section alignment is actually for payload, so we need to add header size\r
         AlignmentMask = Alignment - 1\r
         # section alignment is actually for payload, so we need to add header size\r

-        PayloadOffset = m._OFF_ + m._HEADER_SIZE_\r
+        PayloadOffset = self._OFF_ + self._HEADER_SIZE_\r

         if (PayloadOffset & (~AlignmentMask)) == 0:\r
             return\r
         NewOffset = (PayloadOffset + AlignmentMask) & (~AlignmentMask)\r
         if (PayloadOffset & (~AlignmentMask)) == 0:\r
             return\r
         NewOffset = (PayloadOffset + AlignmentMask) & (~AlignmentMask)\r

-        while (NewOffset - PayloadOffset) < m._HEADER_SIZE_:\r
-            NewOffset += m._Alignment\r
+        while (NewOffset - PayloadOffset) < self._HEADER_SIZE_:\r
+            NewOffset += self._Alignment\r

 \r
 \r

-    def tofile(m, f):\r
-        m.Size = len(m)\r
-        Image.tofile(m, f)\r
-        for Offset in m._SubImages:\r
-            m._SubImages[Offset].tofile(f)\r
+    def tofile(self, f):\r
+        self.Size = len(self)\r
+        Image.tofile(self, f)\r
+        for Offset in self._SubImages:\r
+            self._SubImages[Offset].tofile(f)\r

 \r
     Type = property(_GetType, _SetType)\r
     Size = property(_GetSize, _SetSize)\r
 \r
     Type = property(_GetType, _SetType)\r
     Size = property(_GetSize, _SetSize)\r


@@ -1043,24 +1036,24 @@ class Ffs(Image):
         # Guid1, Guid2, Guid3, Guid4, Guid5, Guid6, Guid7, Guid8, Guid9, Guid10, Guid11\r
         return self.GetField(self._NAME_)\r
 \r
         # Guid1, Guid2, Guid3, Guid4, Guid5, Guid6, Guid7, Guid8, Guid9, Guid10, Guid11\r
         return self.GetField(self._NAME_)\r
 \r

-    def _SetSize(m, Size):\r
+    def _SetSize(self, Size):\r

         Size1 = Size & 0xFF\r
         Size2 = (Size & 0xFF00) >> 8\r
         Size3 = (Size & 0xFF0000) >> 16\r
         Size1 = Size & 0xFF\r
         Size2 = (Size & 0xFF00) >> 8\r
         Size3 = (Size & 0xFF0000) >> 16\r

-        m.SetField(m._SIZE_, 0, Size1, Size2, Size3)\r
+        self.SetField(self._SIZE_, 0, Size1, Size2, Size3)\r

 \r
 \r

-    def _GetSize(m):\r
-        Size1, Size2, Size3 = m.GetField(m._SIZE_)\r
+    def _GetSize(self):\r
+        Size1, Size2, Size3 = self.GetField(self._SIZE_)\r

         return Size1 + (Size2 << 8) + (Size3 << 16)\r
 \r
         return Size1 + (Size2 << 8) + (Size3 << 16)\r
 \r

-    def _SetType(m, Type):\r
-        m.SetField(m._TYPE_, 0, Type)\r
+    def _SetType(self, Type):\r
+        self.SetField(self._TYPE_, 0, Type)\r

 \r
 \r

-    def _GetType(m):\r
-        return m.GetField(m._TYPE_)[0]\r
+    def _GetType(self):\r
+        return self.GetField(self._TYPE_)[0]\r

 \r
     def _SetAttributes(self, Value):\r
 \r
     def _SetAttributes(self, Value):\r

-        self.SetField(m._ATTR_, 0, Value)\r
+        self.SetField(self._ATTR_, 0, Value)\r

 \r
     def _GetAttributes(self):\r
         return self.GetField(self._ATTR_)[0]\r
 \r
     def _GetAttributes(self):\r
         return self.GetField(self._ATTR_)[0]\r


@@ -1079,10 +1072,10 @@ class Ffs(Image):
         return (self.Attributes & self.FFS_ATTRIB_DATA_ALIGNMENT) >> 3\r
 \r
     def _SetState(self, Value):\r
         return (self.Attributes & self.FFS_ATTRIB_DATA_ALIGNMENT) >> 3\r
 \r
     def _SetState(self, Value):\r

-        self.SetField(m._STATE_, 0, Value)\r
+        self.SetField(self._STATE_, 0, Value)\r

 \r
     def _GetState(self):\r
 \r
     def _GetState(self):\r

-        return self.GetField(m._STATE_)[0]\r
+        return self.GetField(self._STATE_)[0]\r

 \r
     Name = property(_GetName, _SetName)\r
     Guid = property(_GetGuid)\r
 \r
     Name = property(_GetName, _SetName)\r
     Guid = property(_GetGuid)\r


@@ -1123,9 +1116,7 @@ class FirmwareVolume(Image):
     def CheckArchProtocol(self):\r
         for Item in EotGlobalData.gArchProtocolGuids:\r
             if Item.lower() not in EotGlobalData.gProtocolList:\r
     def CheckArchProtocol(self):\r
         for Item in EotGlobalData.gArchProtocolGuids:\r
             if Item.lower() not in EotGlobalData.gProtocolList:\r

-\r

                 return False\r
                 return False\r

-\r

         return True\r
 \r
     def ParseDepex(self, Depex, Type):\r
         return True\r
 \r
     def ParseDepex(self, Depex, Type):\r


@@ -1378,7 +1369,6 @@ class FirmwareVolume(Image):
                     if Section.Type == 0x1B:\r
                         CouldBeLoaded, DepexString, FileDepex = self.ParseDepex(Section._SubImages[4], 'Ppi')\r
                         break\r
                     if Section.Type == 0x1B:\r
                         CouldBeLoaded, DepexString, FileDepex = self.ParseDepex(Section._SubImages[4], 'Ppi')\r
                         break\r

-\r

                     if Section.Type == 0x01:\r
                         CompressSections = Section._SubImages[4]\r
                         for CompressSection in CompressSections.Sections:\r
                     if Section.Type == 0x01:\r
                         CompressSections = Section._SubImages[4]\r
                         for CompressSection in CompressSections.Sections:\r