BaseTools:Make BaseTools support new rules to generate RAW FFS FILE

[mirror_edk2.git] / BaseTools / Source / Python / GenFds / FdfParser.py

diff --git a/BaseTools/Source/Python/GenFds/FdfParser.py b/BaseTools/Source/Python/GenFds/FdfParser.py
index 9b7e898570a3ecfd0d34364fa1ba65b4f519bd59..fb5fd85e0a825ebf3341e2ca706af9b0b37b57c3 100644 (file)
--- a/BaseTools/Source/Python/GenFds/FdfParser.py
+++ b/BaseTools/Source/Python/GenFds/FdfParser.py
@@ -4,88 +4,73 @@
 #  Copyright (c) 2007 - 2018, Intel Corporation. All rights reserved.<BR>\r
 #  Copyright (c) 2015, Hewlett Packard Enterprise Development, L.P.<BR>\r
 #\r
 #  Copyright (c) 2007 - 2018, Intel Corporation. All rights reserved.<BR>\r
 #  Copyright (c) 2015, Hewlett Packard Enterprise Development, L.P.<BR>\r
 #\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
-#  http://opensource.org/licenses/bsd-license.php\r
-#\r
-#  THE PROGRAM IS DISTRIBUTED UNDER THE BSD LICENSE ON AN "AS IS" BASIS,\r
-#  WITHOUT WARRANTIES OR REPRESENTATIONS OF ANY KIND, EITHER EXPRESS OR IMPLIED.\r
+#  SPDX-License-Identifier: BSD-2-Clause-Patent\r

 #\r
 \r
 ##\r
 # Import Modules\r
 #\r
 #\r
 \r
 ##\r
 # Import Modules\r
 #\r

-import re\r
-\r
-import Fd\r
-import Region\r
-import Fv\r
-import AprioriSection\r
-import FfsInfStatement\r
-import FfsFileStatement\r
-import VerSection\r
-import UiSection\r
-import FvImageSection\r
-import DataSection\r
-import DepexSection\r
-import CompressSection\r
-import GuidSection\r
-import Capsule\r
-import CapsuleData\r
-import Rule\r
-import RuleComplexFile\r
-import RuleSimpleFile\r
-import EfiSection\r
-import Vtf\r
-import ComponentStatement\r
-import OptionRom\r
-import OptRomInfStatement\r
-import OptRomFileStatement\r
-import string\r
-\r
-from GenFdsGlobalVariable import GenFdsGlobalVariable\r
+from __future__ import print_function\r
+from __future__ import absolute_import\r
+from re import compile, DOTALL\r
+from string import hexdigits\r
+from uuid import UUID\r
+\r

 from Common.BuildToolError import *\r
 from Common import EdkLogger\r
 from Common.BuildToolError import *\r
 from Common import EdkLogger\r

-from Common.Misc import PathClass\r
-from Common.String import NormPath\r
-import Common.GlobalData as GlobalData\r
-from Common.Expression import *\r
+from Common.Misc import PathClass, tdict, ProcessDuplicatedInf\r
+from Common.StringUtils import NormPath, ReplaceMacro\r

 from Common import GlobalData\r
 from Common import GlobalData\r

-from Common.String import ReplaceMacro\r
-import uuid\r
-from Common.Misc import tdict\r
+from Common.Expression import *\r
+from Common.DataType import *\r

 from Common.MultipleWorkspace import MultipleWorkspace as mws\r
 import Common.LongFilePathOs as os\r
 from Common.LongFilePathSupport import OpenLongFilePath as open\r
 from Common.MultipleWorkspace import MultipleWorkspace as mws\r
 import Common.LongFilePathOs as os\r
 from Common.LongFilePathSupport import OpenLongFilePath as open\r

-from Capsule import EFI_CERT_TYPE_PKCS7_GUID\r
-from Capsule import EFI_CERT_TYPE_RSA2048_SHA256_GUID\r

 from Common.RangeExpression import RangeExpression\r
 from Common.RangeExpression import RangeExpression\r

-from Common.FdfParserLite import FileExtensionPattern,TokenFindPattern\r
-\r
-##define T_CHAR_SPACE                ' '\r
-##define T_CHAR_NULL                 '\0'\r
-##define T_CHAR_CR                   '\r'\r
-##define T_CHAR_TAB                  '\t'\r
-##define T_CHAR_LF                   '\n'\r
-##define T_CHAR_SLASH                '/'\r
-##define T_CHAR_BACKSLASH            '\\'\r
-##define T_CHAR_DOUBLE_QUOTE         '\"'\r
-##define T_CHAR_SINGLE_QUOTE         '\''\r
-##define T_CHAR_STAR                 '*'\r
-##define T_CHAR_HASH                 '#'\r
-\r
-(T_CHAR_SPACE, T_CHAR_NULL, T_CHAR_CR, T_CHAR_TAB, T_CHAR_LF, T_CHAR_SLASH, \\r
-T_CHAR_BACKSLASH, T_CHAR_DOUBLE_QUOTE, T_CHAR_SINGLE_QUOTE, T_CHAR_STAR, T_CHAR_HASH) = \\r
-(' ', '\0', '\r', '\t', '\n', '/', '\\', '\"', '\'', '*', '#')\r
-\r
-SEPERATOR_TUPLE = ('=', '|', ',', '{', '}')\r
-\r
-RegionSizePattern = re.compile("\s*(?P<base>(?:0x|0X)?[a-fA-F0-9]+)\s*\|\s*(?P<size>(?:0x|0X)?[a-fA-F0-9]+)\s*")\r
-RegionSizeGuidPattern = re.compile("\s*(?P<base>\w+\.\w+)\s*\|\s*(?P<size>\w+\.\w+)\s*")\r
-RegionOffsetPcdPattern = re.compile("\s*(?P<base>\w+\.\w+)\s*$")\r
-ShortcutPcdPattern = re.compile("\s*\w+\s*=\s*(?P<value>(?:0x|0X)?[a-fA-F0-9]+)\s*\|\s*(?P<name>\w+\.\w+)\s*")\r
-\r
+from collections import OrderedDict\r
+\r
+from .Fd import FD\r
+from .Region import Region\r
+from .Fv import FV\r
+from .AprioriSection import AprioriSection\r
+from .FfsInfStatement import FfsInfStatement\r
+from .FfsFileStatement import FileStatement\r
+from .VerSection import VerSection\r
+from .UiSection import UiSection\r
+from .FvImageSection import FvImageSection\r
+from .DataSection import DataSection\r
+from .DepexSection import DepexSection\r
+from .CompressSection import CompressSection\r
+from .GuidSection import GuidSection\r
+from .Capsule import EFI_CERT_TYPE_PKCS7_GUID, EFI_CERT_TYPE_RSA2048_SHA256_GUID, Capsule\r
+from .CapsuleData import CapsuleFfs, CapsulePayload, CapsuleFv, CapsuleFd, CapsuleAnyFile, CapsuleAfile\r
+from .RuleComplexFile import RuleComplexFile\r
+from .RuleSimpleFile import RuleSimpleFile\r
+from .EfiSection import EfiSection\r
+from .OptionRom import OPTIONROM\r
+from .OptRomInfStatement import OptRomInfStatement, OverrideAttribs\r
+from .OptRomFileStatement import OptRomFileStatement\r
+from .GenFdsGlobalVariable import GenFdsGlobalVariable\r
+\r
+T_CHAR_CR = '\r'\r
+T_CHAR_TAB = '\t'\r
+T_CHAR_DOUBLE_QUOTE = '\"'\r
+T_CHAR_SINGLE_QUOTE = '\''\r
+T_CHAR_BRACE_R = '}'\r
+\r
+SEPARATORS = {TAB_EQUAL_SPLIT, TAB_VALUE_SPLIT, TAB_COMMA_SPLIT, '{', T_CHAR_BRACE_R}\r
+ALIGNMENTS = {"Auto", "8", "16", "32", "64", "128", "512", "1K", "4K", "32K", "64K", "128K",\r
+                                    "256K", "512K", "1M", "2M", "4M", "8M", "16M"}\r
+ALIGNMENT_NOAUTO = ALIGNMENTS - {"Auto"}\r
+CR_LB_SET = {T_CHAR_CR, TAB_LINE_BREAK}\r
+\r
+RegionSizePattern = compile("\s*(?P<base>(?:0x|0X)?[a-fA-F0-9]+)\s*\|\s*(?P<size>(?:0x|0X)?[a-fA-F0-9]+)\s*")\r
+RegionSizeGuidPattern = compile("\s*(?P<base>\w+\.\w+[\.\w\[\]]*)\s*\|\s*(?P<size>\w+\.\w+[\.\w\[\]]*)\s*")\r
+RegionOffsetPcdPattern = compile("\s*(?P<base>\w+\.\w+[\.\w\[\]]*)\s*$")\r
+ShortcutPcdPattern = compile("\s*\w+\s*=\s*(?P<value>(?:0x|0X)?[a-fA-F0-9]+)\s*\|\s*(?P<name>\w+\.\w+)\s*")\r
+BaseAddrValuePattern = compile('^0[xX][0-9a-fA-F]+')\r
+FileExtensionPattern = compile(r'([a-zA-Z][a-zA-Z0-9]*)')\r
+TokenFindPattern = compile(r'([a-zA-Z0-9\-]+|\$\(TARGET\)|\*)_([a-zA-Z0-9\-]+|\$\(TOOL_CHAIN_TAG\)|\*)_([a-zA-Z0-9\-]+|\$\(ARCH\)|\*)')\r

 AllIncludeFileList = []\r
 \r
 # Get the closest parent\r
 AllIncludeFileList = []\r
 \r
 # Get the closest parent\r


@@ -104,7 +89,6 @@ def IsValidInclude (File, Line):
     return True\r
 \r
 def GetRealFileLine (File, Line):\r
     return True\r
 \r
 def GetRealFileLine (File, Line):\r

-\r

     InsertedLines = 0\r
     for Profile in AllIncludeFileList:\r
         if Profile.IsLineInFile(Line):\r
     InsertedLines = 0\r
     for Profile in AllIncludeFileList:\r
         if Profile.IsLineInFile(Line):\r


@@ -116,7 +100,7 @@ def GetRealFileLine (File, Line):
 \r
 ## The exception class that used to report error messages when parsing FDF\r
 #\r
 \r
 ## The exception class that used to report error messages when parsing FDF\r
 #\r

-# Currently the "ToolName" is set to be "FDF Parser".\r
+# Currently the "ToolName" is set to be "FdfParser".\r

 #\r
 class Warning (Exception):\r
     ## The constructor\r
 #\r
 class Warning (Exception):\r
     ## The constructor\r


@@ -127,7 +111,6 @@ class Warning (Exception):
     #   @param  Line        The Line number that error occurs\r
     #\r
     def __init__(self, Str, File = None, Line = None):\r
     #   @param  Line        The Line number that error occurs\r
     #\r
     def __init__(self, Str, File = None, Line = None):\r

-\r

         FileLineTuple = GetRealFileLine(File, Line)\r
         self.FileName = FileLineTuple[0]\r
         self.LineNumber = FileLineTuple[1]\r
         FileLineTuple = GetRealFileLine(File, Line)\r
         self.FileName = FileLineTuple[0]\r
         self.LineNumber = FileLineTuple[1]\r


@@ -138,11 +121,29 @@ class Warning (Exception):
     def __str__(self):\r
         return self.Message\r
 \r
     def __str__(self):\r
         return self.Message\r
 \r

+    # helper functions to facilitate consistency in warnings\r
+    # each function is for a different common warning\r
+    @staticmethod\r
+    def Expected(Str, File, Line):\r
+        return Warning("expected {}".format(Str), File, Line)\r
+    @staticmethod\r
+    def ExpectedEquals(File, Line):\r
+        return Warning.Expected("'='", File, Line)\r
+    @staticmethod\r
+    def ExpectedCurlyOpen(File, Line):\r
+        return Warning.Expected("'{'", File, Line)\r
+    @staticmethod\r
+    def ExpectedCurlyClose(File, Line):\r
+        return Warning.Expected("'}'", File, Line)\r
+    @staticmethod\r
+    def ExpectedBracketClose(File, Line):\r
+        return Warning.Expected("']'", File, Line)\r
+\r

 ## The Include file content class that used to record file data when parsing include file\r
 #\r
 # May raise Exception when opening file.\r
 #\r
 ## The Include file content class that used to record file data when parsing include file\r
 #\r
 # May raise Exception when opening file.\r
 #\r

-class IncludeFileProfile :\r
+class IncludeFileProfile:\r

     ## The constructor\r
     #\r
     #   @param  self        The object pointer\r
     ## The constructor\r
     #\r
     #   @param  self        The object pointer\r


@@ -152,16 +153,11 @@ class IncludeFileProfile :
         self.FileName = FileName\r
         self.FileLinesList = []\r
         try:\r
         self.FileName = FileName\r
         self.FileLinesList = []\r
         try:\r

-            fsock = open(FileName, "rb", 0)\r
-            try:\r
+            with open(FileName, "r") as fsock:\r

                 self.FileLinesList = fsock.readlines()\r
                 for index, line in enumerate(self.FileLinesList):\r
                 self.FileLinesList = fsock.readlines()\r
                 for index, line in enumerate(self.FileLinesList):\r

-                    if not line.endswith('\n'):\r
-                        self.FileLinesList[index] += '\n'\r
-\r
-            finally:\r
-                fsock.close()\r
-\r
+                    if not line.endswith(TAB_LINE_BREAK):\r
+                        self.FileLinesList[index] += TAB_LINE_BREAK\r

         except:\r
             EdkLogger.error("FdfParser", FILE_OPEN_FAILURE, ExtraData=FileName)\r
 \r
         except:\r
             EdkLogger.error("FdfParser", FILE_OPEN_FAILURE, ExtraData=FileName)\r
 \r


@@ -169,7 +165,7 @@ class IncludeFileProfile :
         self.InsertAdjust = 0\r
         self.IncludeFileList = []\r
         self.Level = 1 # first level include file\r
         self.InsertAdjust = 0\r
         self.IncludeFileList = []\r
         self.Level = 1 # first level include file\r

-    \r
+\r

     def GetTotalLines(self):\r
         TotalLines = self.InsertAdjust + len(self.FileLinesList)\r
 \r
     def GetTotalLines(self):\r
         TotalLines = self.InsertAdjust + len(self.FileLinesList)\r
 \r


@@ -187,7 +183,7 @@ class IncludeFileProfile :
     def GetLineInFile(self, Line):\r
         if not self.IsLineInFile (Line):\r
             return (self.FileName, -1)\r
     def GetLineInFile(self, Line):\r
         if not self.IsLineInFile (Line):\r
             return (self.FileName, -1)\r

-        \r
+\r

         InsertedLines = self.InsertStartLineNumber\r
 \r
         for Profile in self.IncludeFileList:\r
         InsertedLines = self.InsertStartLineNumber\r
 \r
         for Profile in self.IncludeFileList:\r


@@ -198,13 +194,11 @@ class IncludeFileProfile :
 \r
         return (self.FileName, Line - InsertedLines + 1)\r
 \r
 \r
         return (self.FileName, Line - InsertedLines + 1)\r
 \r

-\r
-\r

 ## The FDF content class that used to record file data when parsing FDF\r
 #\r
 # May raise Exception when opening file.\r
 #\r
 ## The FDF content class that used to record file data when parsing FDF\r
 #\r
 # May raise Exception when opening file.\r
 #\r

-class FileProfile :\r
+class FileProfile:\r

     ## The constructor\r
     #\r
     #   @param  self        The object pointer\r
     ## The constructor\r
     #\r
     #   @param  self        The object pointer\r


@@ -213,28 +207,25 @@ class FileProfile :
     def __init__(self, FileName):\r
         self.FileLinesList = []\r
         try:\r
     def __init__(self, FileName):\r
         self.FileLinesList = []\r
         try:\r

-            fsock = open(FileName, "rb", 0)\r
-            try:\r
+            with open(FileName, "r") as fsock:\r

                 self.FileLinesList = fsock.readlines()\r
                 self.FileLinesList = fsock.readlines()\r

-            finally:\r
-                fsock.close()\r

 \r
         except:\r
             EdkLogger.error("FdfParser", FILE_OPEN_FAILURE, ExtraData=FileName)\r
 \r
 \r
         except:\r
             EdkLogger.error("FdfParser", FILE_OPEN_FAILURE, ExtraData=FileName)\r
 \r

-\r
-        self.PcdDict = {}\r
+        self.FileName = FileName\r
+        self.PcdDict = OrderedDict()\r
+        self.PcdLocalDict = OrderedDict()\r

         self.InfList = []\r
         self.InfDict = {'ArchTBD':[]}\r
         # ECC will use this Dict and List information\r
         self.PcdFileLineDict = {}\r
         self.InfFileLineList = []\r
         self.InfList = []\r
         self.InfDict = {'ArchTBD':[]}\r
         # ECC will use this Dict and List information\r
         self.PcdFileLineDict = {}\r
         self.InfFileLineList = []\r

-        \r
+\r

         self.FdDict = {}\r
         self.FdNameNotSet = False\r
         self.FvDict = {}\r
         self.CapsuleDict = {}\r
         self.FdDict = {}\r
         self.FdNameNotSet = False\r
         self.FvDict = {}\r
         self.CapsuleDict = {}\r

-        self.VtfList = []\r

         self.RuleDict = {}\r
         self.OptRomDict = {}\r
         self.FmpPayloadDict = {}\r
         self.RuleDict = {}\r
         self.OptRomDict = {}\r
         self.FmpPayloadDict = {}\r


@@ -260,41 +251,37 @@ class FdfParser:
         self.CurrentOffsetWithinLine = 0\r
         self.CurrentFdName = None\r
         self.CurrentFvName = None\r
         self.CurrentOffsetWithinLine = 0\r
         self.CurrentFdName = None\r
         self.CurrentFvName = None\r

-        self.__Token = ""\r
-        self.__SkippedChars = ""\r
+        self._Token = ""\r
+        self._SkippedChars = ""\r

         GlobalData.gFdfParser = self\r
 \r
         # Used to section info\r
         GlobalData.gFdfParser = self\r
 \r
         # Used to section info\r

-        self.__CurSection = []\r
+        self._CurSection = []\r

         # Key: [section name, UI name, arch]\r
         # Key: [section name, UI name, arch]\r

-        # Value: {MACRO_NAME : MACRO_VALUE}\r
-        self.__MacroDict = tdict(True, 3)\r
-        self.__PcdDict = {}\r
+        # Value: {MACRO_NAME: MACRO_VALUE}\r
+        self._MacroDict = tdict(True, 3)\r
+        self._PcdDict = OrderedDict()\r

 \r
 \r

-        self.__WipeOffArea = []\r
+        self._WipeOffArea = []\r

         if GenFdsGlobalVariable.WorkSpaceDir == '':\r
             GenFdsGlobalVariable.WorkSpaceDir = os.getenv("WORKSPACE")\r
 \r
         if GenFdsGlobalVariable.WorkSpaceDir == '':\r
             GenFdsGlobalVariable.WorkSpaceDir = os.getenv("WORKSPACE")\r
 \r

-    ## __SkipWhiteSpace() method\r
+    ## _SkipWhiteSpace() method\r

     #\r
     #\r

-    #   Skip white spaces from current char, return number of chars skipped\r
+    #   Skip white spaces from current char.\r

     #\r
     #   @param  self        The object pointer\r
     #\r
     #   @param  self        The object pointer\r

-    #   @retval Count       The number of chars skipped\r

     #\r
     #\r

-    def __SkipWhiteSpace(self):\r
-        Count = 0\r
-        while not self.__EndOfFile():\r
-            Count += 1\r
-            if self.__CurrentChar() in (T_CHAR_NULL, T_CHAR_CR, T_CHAR_LF, T_CHAR_SPACE, T_CHAR_TAB):\r
-                self.__SkippedChars += str(self.__CurrentChar())\r
-                self.__GetOneChar()\r
-\r
+    def _SkipWhiteSpace(self):\r
+        while not self._EndOfFile():\r
+            if self._CurrentChar() in {TAB_PRINTCHAR_NUL, T_CHAR_CR, TAB_LINE_BREAK, TAB_SPACE_SPLIT, T_CHAR_TAB}:\r
+                self._SkippedChars += str(self._CurrentChar())\r
+                self._GetOneChar()\r

             else:\r
             else:\r

-                Count = Count - 1\r
-                return Count\r
+                return\r
+        return\r

 \r
 \r

-    ## __EndOfFile() method\r
+    ## _EndOfFile() method\r

     #\r
     #   Judge current buffer pos is at file end\r
     #\r
     #\r
     #   Judge current buffer pos is at file end\r
     #\r


@@ -302,17 +289,16 @@ class FdfParser:
     #   @retval True        Current File buffer position is at file end\r
     #   @retval False       Current File buffer position is NOT at file end\r
     #\r
     #   @retval True        Current File buffer position is at file end\r
     #   @retval False       Current File buffer position is NOT at file end\r
     #\r

-    def __EndOfFile(self):\r
+    def _EndOfFile(self):\r

         NumberOfLines = len(self.Profile.FileLinesList)\r
         SizeOfLastLine = len(self.Profile.FileLinesList[-1])\r
         if self.CurrentLineNumber == NumberOfLines and self.CurrentOffsetWithinLine >= SizeOfLastLine - 1:\r
             return True\r
         NumberOfLines = len(self.Profile.FileLinesList)\r
         SizeOfLastLine = len(self.Profile.FileLinesList[-1])\r
         if self.CurrentLineNumber == NumberOfLines and self.CurrentOffsetWithinLine >= SizeOfLastLine - 1:\r
             return True\r

-        elif self.CurrentLineNumber > NumberOfLines:\r
+        if self.CurrentLineNumber > NumberOfLines:\r

             return True\r
             return True\r

-        else:\r
-            return False\r
+        return False\r

 \r
 \r

-    ## __EndOfLine() method\r
+    ## _EndOfLine() method\r

     #\r
     #   Judge current buffer pos is at line end\r
     #\r
     #\r
     #   Judge current buffer pos is at line end\r
     #\r


@@ -320,14 +306,13 @@ class FdfParser:
     #   @retval True        Current File buffer position is at line end\r
     #   @retval False       Current File buffer position is NOT at line end\r
     #\r
     #   @retval True        Current File buffer position is at line end\r
     #   @retval False       Current File buffer position is NOT at line end\r
     #\r

-    def __EndOfLine(self):\r
+    def _EndOfLine(self):\r

         if self.CurrentLineNumber > len(self.Profile.FileLinesList):\r
             return True\r
         SizeOfCurrentLine = len(self.Profile.FileLinesList[self.CurrentLineNumber - 1])\r
         if self.CurrentOffsetWithinLine >= SizeOfCurrentLine:\r
             return True\r
         if self.CurrentLineNumber > len(self.Profile.FileLinesList):\r
             return True\r
         SizeOfCurrentLine = len(self.Profile.FileLinesList[self.CurrentLineNumber - 1])\r
         if self.CurrentOffsetWithinLine >= SizeOfCurrentLine:\r
             return True\r

-        else:\r
-            return False\r
+        return False\r

 \r
     ## Rewind() method\r
     #\r
 \r
     ## Rewind() method\r
     #\r


@@ -335,13 +320,13 @@ class FdfParser:
     #\r
     #   @param  self        The object pointer\r
     #   @param  DestLine    Optional new destination line number.\r
     #\r
     #   @param  self        The object pointer\r
     #   @param  DestLine    Optional new destination line number.\r

-    #   @param  DestOffset  Optional new destination offset.     \r
+    #   @param  DestOffset  Optional new destination offset.\r

     #\r
     #\r

-    def Rewind(self, DestLine = 1, DestOffset = 0):  \r
-        self.CurrentLineNumber = DestLine           \r
-        self.CurrentOffsetWithinLine = DestOffset   \r
+    def Rewind(self, DestLine = 1, DestOffset = 0):\r
+        self.CurrentLineNumber = DestLine\r
+        self.CurrentOffsetWithinLine = DestOffset\r

 \r
 \r

-    ## __UndoOneChar() method\r
+    ## _UndoOneChar() method\r

     #\r
     #   Go back one char in the file buffer\r
     #\r
     #\r
     #   Go back one char in the file buffer\r
     #\r


@@ -349,78 +334,78 @@ class FdfParser:
     #   @retval True        Successfully go back one char\r
     #   @retval False       Not able to go back one char as file beginning reached\r
     #\r
     #   @retval True        Successfully go back one char\r
     #   @retval False       Not able to go back one char as file beginning reached\r
     #\r

-    def __UndoOneChar(self):\r
-\r
+    def _UndoOneChar(self):\r

         if self.CurrentLineNumber == 1 and self.CurrentOffsetWithinLine == 0:\r
             return False\r
         elif self.CurrentOffsetWithinLine == 0:\r
             self.CurrentLineNumber -= 1\r
         if self.CurrentLineNumber == 1 and self.CurrentOffsetWithinLine == 0:\r
             return False\r
         elif self.CurrentOffsetWithinLine == 0:\r
             self.CurrentLineNumber -= 1\r

-            self.CurrentOffsetWithinLine = len(self.__CurrentLine()) - 1\r
+            self.CurrentOffsetWithinLine = len(self._CurrentLine()) - 1\r

         else:\r
             self.CurrentOffsetWithinLine -= 1\r
         return True\r
 \r
         else:\r
             self.CurrentOffsetWithinLine -= 1\r
         return True\r
 \r

-    ## __GetOneChar() method\r
+    ## _GetOneChar() method\r

     #\r
     #   Move forward one char in the file buffer\r
     #\r
     #   @param  self        The object pointer\r
     #\r
     #\r
     #   Move forward one char in the file buffer\r
     #\r
     #   @param  self        The object pointer\r
     #\r

-    def __GetOneChar(self):\r
+    def _GetOneChar(self):\r

         if self.CurrentOffsetWithinLine == len(self.Profile.FileLinesList[self.CurrentLineNumber - 1]) - 1:\r
             self.CurrentLineNumber += 1\r
             self.CurrentOffsetWithinLine = 0\r
         else:\r
             self.CurrentOffsetWithinLine += 1\r
 \r
         if self.CurrentOffsetWithinLine == len(self.Profile.FileLinesList[self.CurrentLineNumber - 1]) - 1:\r
             self.CurrentLineNumber += 1\r
             self.CurrentOffsetWithinLine = 0\r
         else:\r
             self.CurrentOffsetWithinLine += 1\r
 \r

-    ## __CurrentChar() method\r
+    ## _CurrentChar() method\r

     #\r
     #   Get the char pointed to by the file buffer pointer\r
     #\r
     #   @param  self        The object pointer\r
     #   @retval Char        Current char\r
     #\r
     #\r
     #   Get the char pointed to by the file buffer pointer\r
     #\r
     #   @param  self        The object pointer\r
     #   @retval Char        Current char\r
     #\r

-    def __CurrentChar(self):\r
+    def _CurrentChar(self):\r

         return self.Profile.FileLinesList[self.CurrentLineNumber - 1][self.CurrentOffsetWithinLine]\r
 \r
         return self.Profile.FileLinesList[self.CurrentLineNumber - 1][self.CurrentOffsetWithinLine]\r
 \r

-    ## __NextChar() method\r
+    ## _NextChar() method\r

     #\r
     #   Get the one char pass the char pointed to by the file buffer pointer\r
     #\r
     #   @param  self        The object pointer\r
     #   @retval Char        Next char\r
     #\r
     #\r
     #   Get the one char pass the char pointed to by the file buffer pointer\r
     #\r
     #   @param  self        The object pointer\r
     #   @retval Char        Next char\r
     #\r

-    def __NextChar(self):\r
+    def _NextChar(self):\r

         if self.CurrentOffsetWithinLine == len(self.Profile.FileLinesList[self.CurrentLineNumber - 1]) - 1:\r
             return self.Profile.FileLinesList[self.CurrentLineNumber][0]\r
         if self.CurrentOffsetWithinLine == len(self.Profile.FileLinesList[self.CurrentLineNumber - 1]) - 1:\r
             return self.Profile.FileLinesList[self.CurrentLineNumber][0]\r

-        else:\r
-            return self.Profile.FileLinesList[self.CurrentLineNumber - 1][self.CurrentOffsetWithinLine + 1]\r
+        return self.Profile.FileLinesList[self.CurrentLineNumber - 1][self.CurrentOffsetWithinLine + 1]\r

 \r
 \r

-    ## __SetCurrentCharValue() method\r
+    ## _SetCurrentCharValue() method\r

     #\r
     #   Modify the value of current char\r
     #\r
     #   @param  self        The object pointer\r
     #   @param  Value       The new value of current char\r
     #\r
     #\r
     #   Modify the value of current char\r
     #\r
     #   @param  self        The object pointer\r
     #   @param  Value       The new value of current char\r
     #\r

-    def __SetCurrentCharValue(self, Value):\r
+    def _SetCurrentCharValue(self, Value):\r

         self.Profile.FileLinesList[self.CurrentLineNumber - 1][self.CurrentOffsetWithinLine] = Value\r
 \r
         self.Profile.FileLinesList[self.CurrentLineNumber - 1][self.CurrentOffsetWithinLine] = Value\r
 \r

-    ## __CurrentLine() method\r
+    ## _CurrentLine() method\r

     #\r
     #   Get the list that contains current line contents\r
     #\r
     #   @param  self        The object pointer\r
     #   @retval List        current line contents\r
     #\r
     #\r
     #   Get the list that contains current line contents\r
     #\r
     #   @param  self        The object pointer\r
     #   @retval List        current line contents\r
     #\r

-    def __CurrentLine(self):\r
+    def _CurrentLine(self):\r

         return self.Profile.FileLinesList[self.CurrentLineNumber - 1]\r
 \r
         return self.Profile.FileLinesList[self.CurrentLineNumber - 1]\r
 \r

-    def __StringToList(self):\r
+    def _StringToList(self):\r

         self.Profile.FileLinesList = [list(s) for s in self.Profile.FileLinesList]\r
         self.Profile.FileLinesList = [list(s) for s in self.Profile.FileLinesList]\r

+        if not self.Profile.FileLinesList:\r
+            EdkLogger.error('FdfParser', FILE_READ_FAILURE, 'The file is empty!', File=self.FileName)\r

         self.Profile.FileLinesList[-1].append(' ')\r
 \r
         self.Profile.FileLinesList[-1].append(' ')\r
 \r

-    def __ReplaceFragment(self, StartPos, EndPos, Value = ' '):\r
+    def _ReplaceFragment(self, StartPos, EndPos, Value = ' '):\r

         if StartPos[0] == EndPos[0]:\r
             Offset = StartPos[1]\r
             while Offset <= EndPos[1]:\r
         if StartPos[0] == EndPos[0]:\r
             Offset = StartPos[1]\r
             while Offset <= EndPos[1]:\r


@@ -429,14 +414,14 @@ class FdfParser:
             return\r
 \r
         Offset = StartPos[1]\r
             return\r
 \r
         Offset = StartPos[1]\r

-        while self.Profile.FileLinesList[StartPos[0]][Offset] not in ('\r', '\n'):\r
+        while self.Profile.FileLinesList[StartPos[0]][Offset] not in CR_LB_SET:\r

             self.Profile.FileLinesList[StartPos[0]][Offset] = Value\r
             Offset += 1\r
 \r
         Line = StartPos[0]\r
         while Line < EndPos[0]:\r
             Offset = 0\r
             self.Profile.FileLinesList[StartPos[0]][Offset] = Value\r
             Offset += 1\r
 \r
         Line = StartPos[0]\r
         while Line < EndPos[0]:\r
             Offset = 0\r

-            while self.Profile.FileLinesList[Line][Offset] not in ('\r', '\n'):\r
+            while self.Profile.FileLinesList[Line][Offset] not in CR_LB_SET:\r

                 self.Profile.FileLinesList[Line][Offset] = Value\r
                 Offset += 1\r
             Line += 1\r
                 self.Profile.FileLinesList[Line][Offset] = Value\r
                 Offset += 1\r
             Line += 1\r


@@ -446,45 +431,29 @@ class FdfParser:
             self.Profile.FileLinesList[EndPos[0]][Offset] = Value\r
             Offset += 1\r
 \r
             self.Profile.FileLinesList[EndPos[0]][Offset] = Value\r
             Offset += 1\r
 \r

-\r
-    def __GetMacroName(self):\r
-        if not self.__GetNextToken():\r
-            raise Warning("expected Macro name", self.FileName, self.CurrentLineNumber)\r
-        MacroName = self.__Token\r
-        NotFlag = False\r
-        if MacroName.startswith('!'):\r
-            NotFlag = True\r
-            MacroName = MacroName[1:].strip()\r
-         \r
-        if not MacroName.startswith('$(') or not MacroName.endswith(')'):\r
-            raise Warning("Macro name expected(Please use '$(%(Token)s)' if '%(Token)s' is a macro.)" % {"Token" : MacroName},\r
-                          self.FileName, self.CurrentLineNumber)\r
-        MacroName = MacroName[2:-1]\r
-        return MacroName, NotFlag\r
-\r
-    def __SetMacroValue(self, Macro, Value):\r
-        if not self.__CurSection:\r
+    def _SetMacroValue(self, Macro, Value):\r
+        if not self._CurSection:\r

             return\r
 \r
         MacroDict = {}\r
             return\r
 \r
         MacroDict = {}\r

-        if not self.__MacroDict[self.__CurSection[0], self.__CurSection[1], self.__CurSection[2]]:\r
-            self.__MacroDict[self.__CurSection[0], self.__CurSection[1], self.__CurSection[2]] = MacroDict\r
+        if not self._MacroDict[self._CurSection[0], self._CurSection[1], self._CurSection[2]]:\r
+            self._MacroDict[self._CurSection[0], self._CurSection[1], self._CurSection[2]] = MacroDict\r

         else:\r
         else:\r

-            MacroDict = self.__MacroDict[self.__CurSection[0], self.__CurSection[1], self.__CurSection[2]]\r
+            MacroDict = self._MacroDict[self._CurSection[0], self._CurSection[1], self._CurSection[2]]\r

         MacroDict[Macro] = Value\r
 \r
         MacroDict[Macro] = Value\r
 \r

-    def __GetMacroValue(self, Macro):\r
+    def _GetMacroValue(self, Macro):\r

         # Highest priority\r
         if Macro in GlobalData.gCommandLineDefines:\r
             return GlobalData.gCommandLineDefines[Macro]\r
         if Macro in GlobalData.gGlobalDefines:\r
             return GlobalData.gGlobalDefines[Macro]\r
 \r
         # Highest priority\r
         if Macro in GlobalData.gCommandLineDefines:\r
             return GlobalData.gCommandLineDefines[Macro]\r
         if Macro in GlobalData.gGlobalDefines:\r
             return GlobalData.gGlobalDefines[Macro]\r
 \r

-        if self.__CurSection:\r
-            MacroDict = self.__MacroDict[\r
-                        self.__CurSection[0],\r
-                        self.__CurSection[1],\r
-                        self.__CurSection[2]\r
+        if self._CurSection:\r
+            MacroDict = self._MacroDict[\r
+                        self._CurSection[0],\r
+                        self._CurSection[1],\r
+                        self._CurSection[2]\r

             ]\r
             if MacroDict and Macro in MacroDict:\r
                 return MacroDict[Macro]\r
             ]\r
             if MacroDict and Macro in MacroDict:\r
                 return MacroDict[Macro]\r


@@ -494,33 +463,26 @@ class FdfParser:
             return GlobalData.gPlatformDefines[Macro]\r
         return None\r
 \r
             return GlobalData.gPlatformDefines[Macro]\r
         return None\r
 \r

-    def __SectionHeaderParser(self, Section):\r
+    def _SectionHeaderParser(self, Section):\r

         # [Defines]\r
         # [FD.UiName]: use dummy instead if UI name is optional\r
         # [FV.UiName]\r
         # [Capsule.UiName]\r
         # [Rule]: don't take rule section into account, macro is not allowed in this section\r
         # [Defines]\r
         # [FD.UiName]: use dummy instead if UI name is optional\r
         # [FV.UiName]\r
         # [Capsule.UiName]\r
         # [Rule]: don't take rule section into account, macro is not allowed in this section\r

-        # [VTF.arch.UiName, arch]\r

         # [OptionRom.DriverName]\r
         # [OptionRom.DriverName]\r

-        self.__CurSection = []\r
-        Section = Section.strip()[1:-1].upper().replace(' ', '').strip('.')\r
-        ItemList = Section.split('.')\r
+        self._CurSection = []\r
+        Section = Section.strip()[1:-1].upper().replace(' ', '').strip(TAB_SPLIT)\r
+        ItemList = Section.split(TAB_SPLIT)\r

         Item = ItemList[0]\r
         if Item == '' or Item == 'RULE':\r
             return\r
 \r
         Item = ItemList[0]\r
         if Item == '' or Item == 'RULE':\r
             return\r
 \r

-        if Item == 'DEFINES':\r
-            self.__CurSection = ['COMMON', 'COMMON', 'COMMON']\r
-        elif Item == 'VTF' and len(ItemList) == 3:\r
-            UiName = ItemList[2]\r
-            Pos = UiName.find(',')\r
-            if Pos != -1:\r
-                UiName = UiName[:Pos]\r
-            self.__CurSection = ['VTF', UiName, ItemList[1]]\r
+        if Item == TAB_COMMON_DEFINES.upper():\r
+            self._CurSection = [TAB_COMMON, TAB_COMMON, TAB_COMMON]\r

         elif len(ItemList) > 1:\r
         elif len(ItemList) > 1:\r

-            self.__CurSection = [ItemList[0], ItemList[1], 'COMMON']\r
+            self._CurSection = [ItemList[0], ItemList[1], TAB_COMMON]\r

         elif len(ItemList) > 0:\r
         elif len(ItemList) > 0:\r

-            self.__CurSection = [ItemList[0], 'DUMMY', 'COMMON']\r
+            self._CurSection = [ItemList[0], 'DUMMY', TAB_COMMON]\r

 \r
     ## PreprocessFile() method\r
     #\r
 \r
     ## PreprocessFile() method\r
     #\r


@@ -532,7 +494,6 @@ class FdfParser:
     #   @param  self        The object pointer\r
     #\r
     def PreprocessFile(self):\r
     #   @param  self        The object pointer\r
     #\r
     def PreprocessFile(self):\r

-\r

         self.Rewind()\r
         InComment = False\r
         DoubleSlashComment = False\r
         self.Rewind()\r
         InComment = False\r
         DoubleSlashComment = False\r


@@ -540,12 +501,12 @@ class FdfParser:
         # HashComment in quoted string " " is ignored.\r
         InString = False\r
 \r
         # HashComment in quoted string " " is ignored.\r
         InString = False\r
 \r

-        while not self.__EndOfFile():\r
+        while not self._EndOfFile():\r

 \r
 \r

-            if self.__CurrentChar() == T_CHAR_DOUBLE_QUOTE and not InComment:\r
+            if self._CurrentChar() == T_CHAR_DOUBLE_QUOTE and not InComment:\r

                 InString = not InString\r
             # meet new line, then no longer in a comment for // and '#'\r
                 InString = not InString\r
             # meet new line, then no longer in a comment for // and '#'\r

-            if self.__CurrentChar() == T_CHAR_LF:\r
+            if self._CurrentChar() == TAB_LINE_BREAK:\r

                 self.CurrentLineNumber += 1\r
                 self.CurrentOffsetWithinLine = 0\r
                 if InComment and DoubleSlashComment:\r
                 self.CurrentLineNumber += 1\r
                 self.CurrentOffsetWithinLine = 0\r
                 if InComment and DoubleSlashComment:\r


@@ -555,33 +516,33 @@ class FdfParser:
                     InComment = False\r
                     HashComment = False\r
             # check for */ comment end\r
                     InComment = False\r
                     HashComment = False\r
             # check for */ comment end\r

-            elif InComment and not DoubleSlashComment and not HashComment and self.__CurrentChar() == T_CHAR_STAR and self.__NextChar() == T_CHAR_SLASH:\r
-                self.__SetCurrentCharValue(T_CHAR_SPACE)\r
-                self.__GetOneChar()\r
-                self.__SetCurrentCharValue(T_CHAR_SPACE)\r
-                self.__GetOneChar()\r
+            elif InComment and not DoubleSlashComment and not HashComment and self._CurrentChar() == TAB_STAR and self._NextChar() == TAB_BACK_SLASH:\r
+                self._SetCurrentCharValue(TAB_SPACE_SPLIT)\r
+                self._GetOneChar()\r
+                self._SetCurrentCharValue(TAB_SPACE_SPLIT)\r
+                self._GetOneChar()\r

                 InComment = False\r
             # set comments to spaces\r
             elif InComment:\r
                 InComment = False\r
             # set comments to spaces\r
             elif InComment:\r

-                self.__SetCurrentCharValue(T_CHAR_SPACE)\r
-                self.__GetOneChar()\r
+                self._SetCurrentCharValue(TAB_SPACE_SPLIT)\r
+                self._GetOneChar()\r

             # check for // comment\r
             # check for // comment\r

-            elif self.__CurrentChar() == T_CHAR_SLASH and self.__NextChar() == T_CHAR_SLASH and not self.__EndOfLine():\r
+            elif self._CurrentChar() == TAB_BACK_SLASH and self._NextChar() == TAB_BACK_SLASH and not self._EndOfLine():\r

                 InComment = True\r
                 DoubleSlashComment = True\r
             # check for '#' comment\r
                 InComment = True\r
                 DoubleSlashComment = True\r
             # check for '#' comment\r

-            elif self.__CurrentChar() == T_CHAR_HASH and not self.__EndOfLine() and not InString:\r
+            elif self._CurrentChar() == TAB_COMMENT_SPLIT and not self._EndOfLine() and not InString:\r

                 InComment = True\r
                 HashComment = True\r
             # check for /* comment start\r
                 InComment = True\r
                 HashComment = True\r
             # check for /* comment start\r

-            elif self.__CurrentChar() == T_CHAR_SLASH and self.__NextChar() == T_CHAR_STAR:\r
-                self.__SetCurrentCharValue( T_CHAR_SPACE)\r
-                self.__GetOneChar()\r
-                self.__SetCurrentCharValue( T_CHAR_SPACE)\r
-                self.__GetOneChar()\r
+            elif self._CurrentChar() == TAB_BACK_SLASH and self._NextChar() == TAB_STAR:\r
+                self._SetCurrentCharValue(TAB_SPACE_SPLIT)\r
+                self._GetOneChar()\r
+                self._SetCurrentCharValue(TAB_SPACE_SPLIT)\r
+                self._GetOneChar()\r

                 InComment = True\r
             else:\r
                 InComment = True\r
             else:\r

-                self.__GetOneChar()\r
+                self._GetOneChar()\r

 \r
         # restore from ListOfList to ListOfString\r
         self.Profile.FileLinesList = ["".join(list) for list in self.Profile.FileLinesList]\r
 \r
         # restore from ListOfList to ListOfString\r
         self.Profile.FileLinesList = ["".join(list) for list in self.Profile.FileLinesList]\r


@@ -595,33 +556,33 @@ class FdfParser:
     #   @param  self        The object pointer\r
     #\r
     def PreprocessIncludeFile(self):\r
     #   @param  self        The object pointer\r
     #\r
     def PreprocessIncludeFile(self):\r

-           # nested include support\r
+      # nested include support\r

         Processed = False\r
         MacroDict = {}\r
         Processed = False\r
         MacroDict = {}\r

-        while self.__GetNextToken():\r
-\r
-            if self.__Token == 'DEFINE':\r
-                if not self.__GetNextToken():\r
-                    raise Warning("expected Macro name", self.FileName, self.CurrentLineNumber)\r
-                Macro = self.__Token\r
-                if not self.__IsToken( "="):\r
-                    raise Warning("expected '='", self.FileName, self.CurrentLineNumber)\r
-                Value = self.__GetExpression()\r
+        while self._GetNextToken():\r
+\r
+            if self._Token == TAB_DEFINE:\r
+                if not self._GetNextToken():\r
+                    raise Warning.Expected("Macro name", self.FileName, self.CurrentLineNumber)\r
+                Macro = self._Token\r
+                if not self._IsToken(TAB_EQUAL_SPLIT):\r
+                    raise Warning.ExpectedEquals(self.FileName, self.CurrentLineNumber)\r
+                Value = self._GetExpression()\r

                 MacroDict[Macro] = Value\r
 \r
                 MacroDict[Macro] = Value\r
 \r

-            elif self.__Token == '!include':\r
+            elif self._Token == TAB_INCLUDE:\r

                 Processed = True\r
                 IncludeLine = self.CurrentLineNumber\r
                 Processed = True\r
                 IncludeLine = self.CurrentLineNumber\r

-                IncludeOffset = self.CurrentOffsetWithinLine - len('!include')\r
-                if not self.__GetNextToken():\r
-                    raise Warning("expected include file name", self.FileName, self.CurrentLineNumber)\r
-                IncFileName = self.__Token\r
+                IncludeOffset = self.CurrentOffsetWithinLine - len(TAB_INCLUDE)\r
+                if not self._GetNextToken():\r
+                    raise Warning.Expected("include file name", self.FileName, self.CurrentLineNumber)\r
+                IncFileName = self._Token\r

                 PreIndex = 0\r
                 StartPos = IncFileName.find('$(', PreIndex)\r
                 EndPos = IncFileName.find(')', StartPos+2)\r
                 while StartPos != -1 and EndPos != -1:\r
                 PreIndex = 0\r
                 StartPos = IncFileName.find('$(', PreIndex)\r
                 EndPos = IncFileName.find(')', StartPos+2)\r
                 while StartPos != -1 and EndPos != -1:\r

-                    Macro = IncFileName[StartPos+2 : EndPos]\r
-                    MacroVal = self.__GetMacroValue(Macro)\r
+                    Macro = IncFileName[StartPos+2: EndPos]\r
+                    MacroVal = self._GetMacroValue(Macro)\r

                     if not MacroVal:\r
                         if Macro in MacroDict:\r
                             MacroVal = MacroDict[Macro]\r
                     if not MacroVal:\r
                         if Macro in MacroDict:\r
                             MacroVal = MacroDict[Macro]\r


@@ -660,7 +621,7 @@ class FdfParser:
                         IncludedFile1 = PathClass(IncludedFile, GlobalData.gWorkspace)\r
                         ErrorCode = IncludedFile1.Validate()[0]\r
                         if ErrorCode != 0:\r
                         IncludedFile1 = PathClass(IncludedFile, GlobalData.gWorkspace)\r
                         ErrorCode = IncludedFile1.Validate()[0]\r
                         if ErrorCode != 0:\r

-                            raise Warning("The include file does not exist under below directories: \n%s\n%s\n%s\n"%(os.path.dirname(self.FileName), PlatformDir, GlobalData.gWorkspace), \r
+                            raise Warning("The include file does not exist under below directories: \n%s\n%s\n%s\n"%(os.path.dirname(self.FileName), PlatformDir, GlobalData.gWorkspace),\r

                                           self.FileName, self.CurrentLineNumber)\r
 \r
                 if not IsValidInclude (IncludedFile1.Path, self.CurrentLineNumber):\r
                                           self.FileName, self.CurrentLineNumber)\r
 \r
                 if not IsValidInclude (IncludedFile1.Path, self.CurrentLineNumber):\r


@@ -678,9 +639,9 @@ class FdfParser:
                     IncFileProfile.Level = ParentProfile.Level + 1\r
                 IncFileProfile.InsertStartLineNumber = InsertAtLine + 1\r
                 # deal with remaining portions after "!include filename", if exists.\r
                     IncFileProfile.Level = ParentProfile.Level + 1\r
                 IncFileProfile.InsertStartLineNumber = InsertAtLine + 1\r
                 # deal with remaining portions after "!include filename", if exists.\r

-                if self.__GetNextToken():\r
+                if self._GetNextToken():\r

                     if self.CurrentLineNumber == CurrentLine:\r
                     if self.CurrentLineNumber == CurrentLine:\r

-                        RemainingLine = self.__CurrentLine()[CurrentOffset:]\r
+                        RemainingLine = self._CurrentLine()[CurrentOffset:]\r

                         self.Profile.FileLinesList.insert(self.CurrentLineNumber, RemainingLine)\r
                         IncFileProfile.InsertAdjust += 1\r
                         self.CurrentLineNumber += 1\r
                         self.Profile.FileLinesList.insert(self.CurrentLineNumber, RemainingLine)\r
                         IncFileProfile.InsertAdjust += 1\r
                         self.CurrentLineNumber += 1\r


@@ -696,25 +657,25 @@ class FdfParser:
 \r
                 # comment out the processed include file statement\r
                 TempList = list(self.Profile.FileLinesList[IncludeLine - 1])\r
 \r
                 # comment out the processed include file statement\r
                 TempList = list(self.Profile.FileLinesList[IncludeLine - 1])\r

-                TempList.insert(IncludeOffset, '#')\r
+                TempList.insert(IncludeOffset, TAB_COMMENT_SPLIT)\r

                 self.Profile.FileLinesList[IncludeLine - 1] = ''.join(TempList)\r
             if Processed: # Nested and back-to-back support\r
                 self.Rewind(DestLine = IncFileProfile.InsertStartLineNumber - 1)\r
                 Processed = False\r
         # Preprocess done.\r
         self.Rewind()\r
                 self.Profile.FileLinesList[IncludeLine - 1] = ''.join(TempList)\r
             if Processed: # Nested and back-to-back support\r
                 self.Rewind(DestLine = IncFileProfile.InsertStartLineNumber - 1)\r
                 Processed = False\r
         # Preprocess done.\r
         self.Rewind()\r

-        \r
+\r

     @staticmethod\r
     @staticmethod\r

-    def __GetIfListCurrentItemStat(IfList):\r
+    def _GetIfListCurrentItemStat(IfList):\r

         if len(IfList) == 0:\r
             return True\r
         if len(IfList) == 0:\r
             return True\r

-        \r
+\r

         for Item in IfList:\r
             if Item[1] == False:\r
                 return False\r
         for Item in IfList:\r
             if Item[1] == False:\r
                 return False\r

-        \r
+\r

         return True\r
         return True\r

-    \r
+\r

     ## PreprocessConditionalStatement() method\r
     #\r
     #   Preprocess conditional statement.\r
     ## PreprocessConditionalStatement() method\r
     #\r
     #   Preprocess conditional statement.\r


@@ -727,35 +688,35 @@ class FdfParser:
         IfList = []\r
         RegionLayoutLine = 0\r
         ReplacedLine = -1\r
         IfList = []\r
         RegionLayoutLine = 0\r
         ReplacedLine = -1\r

-        while self.__GetNextToken():\r
+        while self._GetNextToken():\r

             # Determine section name and the location dependent macro\r
             # Determine section name and the location dependent macro\r

-            if self.__GetIfListCurrentItemStat(IfList):\r
-                if self.__Token.startswith('['):\r
-                    Header = self.__Token\r
-                    if not self.__Token.endswith(']'):\r
-                        self.__SkipToToken(']')\r
-                        Header += self.__SkippedChars\r
+            if self._GetIfListCurrentItemStat(IfList):\r
+                if self._Token.startswith(TAB_SECTION_START):\r
+                    Header = self._Token\r
+                    if not self._Token.endswith(TAB_SECTION_END):\r
+                        self._SkipToToken(TAB_SECTION_END)\r
+                        Header += self._SkippedChars\r

                     if Header.find('$(') != -1:\r
                         raise Warning("macro cannot be used in section header", self.FileName, self.CurrentLineNumber)\r
                     if Header.find('$(') != -1:\r
                         raise Warning("macro cannot be used in section header", self.FileName, self.CurrentLineNumber)\r

-                    self.__SectionHeaderParser(Header)\r
+                    self._SectionHeaderParser(Header)\r

                     continue\r
                 # Replace macros except in RULE section or out of section\r
                     continue\r
                 # Replace macros except in RULE section or out of section\r

-                elif self.__CurSection and ReplacedLine != self.CurrentLineNumber:\r
+                elif self._CurSection and ReplacedLine != self.CurrentLineNumber:\r

                     ReplacedLine = self.CurrentLineNumber\r
                     ReplacedLine = self.CurrentLineNumber\r

-                    self.__UndoToken()\r
+                    self._UndoToken()\r

                     CurLine = self.Profile.FileLinesList[ReplacedLine - 1]\r
                     PreIndex = 0\r
                     StartPos = CurLine.find('$(', PreIndex)\r
                     EndPos = CurLine.find(')', StartPos+2)\r
                     CurLine = self.Profile.FileLinesList[ReplacedLine - 1]\r
                     PreIndex = 0\r
                     StartPos = CurLine.find('$(', PreIndex)\r
                     EndPos = CurLine.find(')', StartPos+2)\r

-                    while StartPos != -1 and EndPos != -1 and self.__Token not in ['!ifdef', '!ifndef', '!if', '!elseif']:\r
-                        MacroName = CurLine[StartPos+2 : EndPos]\r
-                        MacorValue = self.__GetMacroValue(MacroName)\r
-                        if MacorValue is not None:\r
-                            CurLine = CurLine.replace('$(' + MacroName + ')', MacorValue, 1)\r
-                            if MacorValue.find('$(') != -1:\r
+                    while StartPos != -1 and EndPos != -1 and self._Token not in {TAB_IF_DEF, TAB_IF_N_DEF, TAB_IF, TAB_ELSE_IF}:\r
+                        MacroName = CurLine[StartPos+2: EndPos]\r
+                        MacroValue = self._GetMacroValue(MacroName)\r
+                        if MacroValue is not None:\r
+                            CurLine = CurLine.replace('$(' + MacroName + ')', MacroValue, 1)\r
+                            if MacroValue.find('$(') != -1:\r

                                 PreIndex = StartPos\r
                             else:\r
                                 PreIndex = StartPos\r
                             else:\r

-                                PreIndex = StartPos + len(MacorValue)\r
+                                PreIndex = StartPos + len(MacroValue)\r

                         else:\r
                             PreIndex = EndPos + 1\r
                         StartPos = CurLine.find('$(', PreIndex)\r
                         else:\r
                             PreIndex = EndPos + 1\r
                         StartPos = CurLine.find('$(', PreIndex)\r


@@ -763,73 +724,74 @@ class FdfParser:
                     self.Profile.FileLinesList[ReplacedLine - 1] = CurLine\r
                     continue\r
 \r
                     self.Profile.FileLinesList[ReplacedLine - 1] = CurLine\r
                     continue\r
 \r

-            if self.__Token == 'DEFINE':\r
-                if self.__GetIfListCurrentItemStat(IfList):\r
-                    if not self.__CurSection:\r
+            if self._Token == TAB_DEFINE:\r
+                if self._GetIfListCurrentItemStat(IfList):\r
+                    if not self._CurSection:\r

                         raise Warning("macro cannot be defined in Rule section or out of section", self.FileName, self.CurrentLineNumber)\r
                     DefineLine = self.CurrentLineNumber - 1\r
                         raise Warning("macro cannot be defined in Rule section or out of section", self.FileName, self.CurrentLineNumber)\r
                     DefineLine = self.CurrentLineNumber - 1\r

-                    DefineOffset = self.CurrentOffsetWithinLine - len('DEFINE')\r
-                    if not self.__GetNextToken():\r
-                        raise Warning("expected Macro name", self.FileName, self.CurrentLineNumber)\r
-                    Macro = self.__Token\r
-                    if not self.__IsToken( "="):\r
-                        raise Warning("expected '='", self.FileName, self.CurrentLineNumber)\r
-    \r
-                    Value = self.__GetExpression()\r
-                    self.__SetMacroValue(Macro, Value)\r
-                    self.__WipeOffArea.append(((DefineLine, DefineOffset), (self.CurrentLineNumber - 1, self.CurrentOffsetWithinLine - 1)))\r
-            elif self.__Token == 'SET':\r
-                if not self.__GetIfListCurrentItemStat(IfList):\r
+                    DefineOffset = self.CurrentOffsetWithinLine - len(TAB_DEFINE)\r
+                    if not self._GetNextToken():\r
+                        raise Warning.Expected("Macro name", self.FileName, self.CurrentLineNumber)\r
+                    Macro = self._Token\r
+                    if not self._IsToken(TAB_EQUAL_SPLIT):\r
+                        raise Warning.ExpectedEquals(self.FileName, self.CurrentLineNumber)\r
+\r
+                    Value = self._GetExpression()\r
+                    self._SetMacroValue(Macro, Value)\r
+                    self._WipeOffArea.append(((DefineLine, DefineOffset), (self.CurrentLineNumber - 1, self.CurrentOffsetWithinLine - 1)))\r
+            elif self._Token == 'SET':\r
+                if not self._GetIfListCurrentItemStat(IfList):\r

                     continue\r
                 SetLine = self.CurrentLineNumber - 1\r
                 SetOffset = self.CurrentOffsetWithinLine - len('SET')\r
                     continue\r
                 SetLine = self.CurrentLineNumber - 1\r
                 SetOffset = self.CurrentOffsetWithinLine - len('SET')\r

-                PcdPair = self.__GetNextPcdName()\r
+                PcdPair = self._GetNextPcdSettings()\r

                 PcdName = "%s.%s" % (PcdPair[1], PcdPair[0])\r
                 PcdName = "%s.%s" % (PcdPair[1], PcdPair[0])\r

-                if not self.__IsToken( "="):\r
-                    raise Warning("expected '='", self.FileName, self.CurrentLineNumber)\r
+                if not self._IsToken(TAB_EQUAL_SPLIT):\r
+                    raise Warning.ExpectedEquals(self.FileName, self.CurrentLineNumber)\r

 \r
 \r

-                Value = self.__GetExpression()\r
-                Value = self.__EvaluateConditional(Value, self.CurrentLineNumber, 'eval', True)\r
+                Value = self._GetExpression()\r
+                Value = self._EvaluateConditional(Value, self.CurrentLineNumber, 'eval', True)\r

 \r
 \r

-                self.__PcdDict[PcdName] = Value\r
+                self._PcdDict[PcdName] = Value\r

 \r
                 self.Profile.PcdDict[PcdPair] = Value\r
 \r
                 self.Profile.PcdDict[PcdPair] = Value\r

+                self.SetPcdLocalation(PcdPair)\r

                 FileLineTuple = GetRealFileLine(self.FileName, self.CurrentLineNumber)\r
                 self.Profile.PcdFileLineDict[PcdPair] = FileLineTuple\r
 \r
                 FileLineTuple = GetRealFileLine(self.FileName, self.CurrentLineNumber)\r
                 self.Profile.PcdFileLineDict[PcdPair] = FileLineTuple\r
 \r

-                self.__WipeOffArea.append(((SetLine, SetOffset), (self.CurrentLineNumber - 1, self.CurrentOffsetWithinLine - 1)))\r
-            elif self.__Token in ('!ifdef', '!ifndef', '!if'):\r
-                IfStartPos = (self.CurrentLineNumber - 1, self.CurrentOffsetWithinLine - len(self.__Token))\r
+                self._WipeOffArea.append(((SetLine, SetOffset), (self.CurrentLineNumber - 1, self.CurrentOffsetWithinLine - 1)))\r
+            elif self._Token in {TAB_IF_DEF, TAB_IF_N_DEF, TAB_IF}:\r
+                IfStartPos = (self.CurrentLineNumber - 1, self.CurrentOffsetWithinLine - len(self._Token))\r

                 IfList.append([IfStartPos, None, None])\r
 \r
                 IfList.append([IfStartPos, None, None])\r
 \r

-                CondLabel = self.__Token\r
-                Expression = self.__GetExpression()\r
-                \r
-                if CondLabel == '!if':\r
-                    ConditionSatisfied = self.__EvaluateConditional(Expression, IfList[-1][0][0] + 1, 'eval')\r
+                CondLabel = self._Token\r
+                Expression = self._GetExpression()\r
+\r
+                if CondLabel == TAB_IF:\r
+                    ConditionSatisfied = self._EvaluateConditional(Expression, IfList[-1][0][0] + 1, 'eval')\r

                 else:\r
                 else:\r

-                    ConditionSatisfied = self.__EvaluateConditional(Expression, IfList[-1][0][0] + 1, 'in')\r
-                    if CondLabel == '!ifndef':\r
+                    ConditionSatisfied = self._EvaluateConditional(Expression, IfList[-1][0][0] + 1, 'in')\r
+                    if CondLabel == TAB_IF_N_DEF:\r

                         ConditionSatisfied = not ConditionSatisfied\r
 \r
                 BranchDetermined = ConditionSatisfied\r
                 IfList[-1] = [IfList[-1][0], ConditionSatisfied, BranchDetermined]\r
                 if ConditionSatisfied:\r
                         ConditionSatisfied = not ConditionSatisfied\r
 \r
                 BranchDetermined = ConditionSatisfied\r
                 IfList[-1] = [IfList[-1][0], ConditionSatisfied, BranchDetermined]\r
                 if ConditionSatisfied:\r

-                    self.__WipeOffArea.append((IfList[-1][0], (self.CurrentLineNumber - 1, self.CurrentOffsetWithinLine - 1)))                 \r
-            elif self.__Token in ('!elseif', '!else'):\r
-                ElseStartPos = (self.CurrentLineNumber - 1, self.CurrentOffsetWithinLine - len(self.__Token))\r
+                    self._WipeOffArea.append((IfList[-1][0], (self.CurrentLineNumber - 1, self.CurrentOffsetWithinLine - 1)))\r
+            elif self._Token in {TAB_ELSE_IF, TAB_ELSE}:\r
+                ElseStartPos = (self.CurrentLineNumber - 1, self.CurrentOffsetWithinLine - len(self._Token))\r

                 if len(IfList) <= 0:\r
                     raise Warning("Missing !if statement", self.FileName, self.CurrentLineNumber)\r
 \r
                 if IfList[-1][1]:\r
                     IfList[-1] = [ElseStartPos, False, True]\r
                 if len(IfList) <= 0:\r
                     raise Warning("Missing !if statement", self.FileName, self.CurrentLineNumber)\r
 \r
                 if IfList[-1][1]:\r
                     IfList[-1] = [ElseStartPos, False, True]\r

-                    self.__WipeOffArea.append((ElseStartPos, (self.CurrentLineNumber - 1, self.CurrentOffsetWithinLine - 1)))\r
+                    self._WipeOffArea.append((ElseStartPos, (self.CurrentLineNumber - 1, self.CurrentOffsetWithinLine - 1)))\r

                 else:\r
                 else:\r

-                    self.__WipeOffArea.append((IfList[-1][0], ElseStartPos))\r
+                    self._WipeOffArea.append((IfList[-1][0], ElseStartPos))\r

                     IfList[-1] = [ElseStartPos, True, IfList[-1][2]]\r
                     IfList[-1] = [ElseStartPos, True, IfList[-1][2]]\r

-                    if self.__Token == '!elseif':\r
-                        Expression = self.__GetExpression()\r
-                        ConditionSatisfied = self.__EvaluateConditional(Expression, IfList[-1][0][0] + 1, 'eval')\r
+                    if self._Token == TAB_ELSE_IF:\r
+                        Expression = self._GetExpression()\r
+                        ConditionSatisfied = self._EvaluateConditional(Expression, IfList[-1][0][0] + 1, 'eval')\r

                         IfList[-1] = [IfList[-1][0], ConditionSatisfied, IfList[-1][2]]\r
 \r
                     if IfList[-1][1]:\r
                         IfList[-1] = [IfList[-1][0], ConditionSatisfied, IfList[-1][2]]\r
 \r
                     if IfList[-1][1]:\r


@@ -837,14 +799,14 @@ class FdfParser:
                             IfList[-1][1] = False\r
                         else:\r
                             IfList[-1][2] = True\r
                             IfList[-1][1] = False\r
                         else:\r
                             IfList[-1][2] = True\r

-                            self.__WipeOffArea.append((IfList[-1][0], (self.CurrentLineNumber - 1, self.CurrentOffsetWithinLine - 1)))\r
-            elif self.__Token == '!endif':\r
+                            self._WipeOffArea.append((IfList[-1][0], (self.CurrentLineNumber - 1, self.CurrentOffsetWithinLine - 1)))\r
+            elif self._Token == '!endif':\r

                 if len(IfList) <= 0:\r
                     raise Warning("Missing !if statement", self.FileName, self.CurrentLineNumber)\r
                 if IfList[-1][1]:\r
                 if len(IfList) <= 0:\r
                     raise Warning("Missing !if statement", self.FileName, self.CurrentLineNumber)\r
                 if IfList[-1][1]:\r

-                    self.__WipeOffArea.append(((self.CurrentLineNumber - 1, self.CurrentOffsetWithinLine - len('!endif')), (self.CurrentLineNumber - 1, self.CurrentOffsetWithinLine - 1)))\r
+                    self._WipeOffArea.append(((self.CurrentLineNumber - 1, self.CurrentOffsetWithinLine - len('!endif')), (self.CurrentLineNumber - 1, self.CurrentOffsetWithinLine - 1)))\r

                 else:\r
                 else:\r

-                    self.__WipeOffArea.append((IfList[-1][0], (self.CurrentLineNumber - 1, self.CurrentOffsetWithinLine - 1)))\r
+                    self._WipeOffArea.append((IfList[-1][0], (self.CurrentLineNumber - 1, self.CurrentOffsetWithinLine - 1)))\r

 \r
                 IfList.pop()\r
             elif not IfList:    # Don't use PCDs inside conditional directive\r
 \r
                 IfList.pop()\r
             elif not IfList:    # Don't use PCDs inside conditional directive\r


@@ -853,7 +815,7 @@ class FdfParser:
                     continue\r
                 SetPcd = ShortcutPcdPattern.match(self.Profile.FileLinesList[self.CurrentLineNumber - 1])\r
                 if SetPcd:\r
                     continue\r
                 SetPcd = ShortcutPcdPattern.match(self.Profile.FileLinesList[self.CurrentLineNumber - 1])\r
                 if SetPcd:\r

-                    self.__PcdDict[SetPcd.group('name')] = SetPcd.group('value')\r
+                    self._PcdDict[SetPcd.group('name')] = SetPcd.group('value')\r

                     RegionLayoutLine = self.CurrentLineNumber\r
                     continue\r
                 RegionSize = RegionSizePattern.match(self.Profile.FileLinesList[self.CurrentLineNumber - 1])\r
                     RegionLayoutLine = self.CurrentLineNumber\r
                     continue\r
                 RegionSize = RegionSizePattern.match(self.Profile.FileLinesList[self.CurrentLineNumber - 1])\r


@@ -864,71 +826,69 @@ class FdfParser:
                 if not RegionSizeGuid:\r
                     RegionLayoutLine = self.CurrentLineNumber + 1\r
                     continue\r
                 if not RegionSizeGuid:\r
                     RegionLayoutLine = self.CurrentLineNumber + 1\r
                     continue\r

-                self.__PcdDict[RegionSizeGuid.group('base')] = RegionSize.group('base')\r
-                self.__PcdDict[RegionSizeGuid.group('size')] = RegionSize.group('size')\r
+                self._PcdDict[RegionSizeGuid.group('base')] = RegionSize.group('base')\r
+                self._PcdDict[RegionSizeGuid.group('size')] = RegionSize.group('size')\r

                 RegionLayoutLine = self.CurrentLineNumber + 1\r
 \r
         if IfList:\r
             raise Warning("Missing !endif", self.FileName, self.CurrentLineNumber)\r
         self.Rewind()\r
 \r
                 RegionLayoutLine = self.CurrentLineNumber + 1\r
 \r
         if IfList:\r
             raise Warning("Missing !endif", self.FileName, self.CurrentLineNumber)\r
         self.Rewind()\r
 \r

-    def __CollectMacroPcd(self):\r
+    def _CollectMacroPcd(self):\r

         MacroDict = {}\r
 \r
         # PCD macro\r
         MacroDict.update(GlobalData.gPlatformPcds)\r
         MacroDict = {}\r
 \r
         # PCD macro\r
         MacroDict.update(GlobalData.gPlatformPcds)\r

-        MacroDict.update(self.__PcdDict)\r
+        MacroDict.update(self._PcdDict)\r

 \r
         # Lowest priority\r
         MacroDict.update(GlobalData.gPlatformDefines)\r
 \r
 \r
         # Lowest priority\r
         MacroDict.update(GlobalData.gPlatformDefines)\r
 \r

-        if self.__CurSection:\r
+        if self._CurSection:\r

             # Defines macro\r
             # Defines macro\r

-            ScopeMacro = self.__MacroDict['COMMON', 'COMMON', 'COMMON']\r
+            ScopeMacro = self._MacroDict[TAB_COMMON, TAB_COMMON, TAB_COMMON]\r

             if ScopeMacro:\r
                 MacroDict.update(ScopeMacro)\r
             if ScopeMacro:\r
                 MacroDict.update(ScopeMacro)\r

-    \r
+\r

             # Section macro\r
             # Section macro\r

-            ScopeMacro = self.__MacroDict[\r
-                        self.__CurSection[0],\r
-                        self.__CurSection[1],\r
-                        self.__CurSection[2]\r
+            ScopeMacro = self._MacroDict[\r
+                        self._CurSection[0],\r
+                        self._CurSection[1],\r
+                        self._CurSection[2]\r

             ]\r
             if ScopeMacro:\r
                 MacroDict.update(ScopeMacro)\r
 \r
         MacroDict.update(GlobalData.gGlobalDefines)\r
         MacroDict.update(GlobalData.gCommandLineDefines)\r
             ]\r
             if ScopeMacro:\r
                 MacroDict.update(ScopeMacro)\r
 \r
         MacroDict.update(GlobalData.gGlobalDefines)\r
         MacroDict.update(GlobalData.gCommandLineDefines)\r

-        if GlobalData.BuildOptionPcd:\r
-            for Item in GlobalData.BuildOptionPcd:\r
-                if type(Item) is tuple:\r
-                    continue\r
-                PcdName, TmpValue = Item.split("=")\r
-                TmpValue = BuildOptionValue(TmpValue, {})\r
-                MacroDict[PcdName.strip()] = TmpValue\r
+        for Item in GlobalData.BuildOptionPcd:\r
+            if isinstance(Item, tuple):\r
+                continue\r
+            PcdName, TmpValue = Item.split(TAB_EQUAL_SPLIT)\r
+            TmpValue = BuildOptionValue(TmpValue, {})\r
+            MacroDict[PcdName.strip()] = TmpValue\r

         # Highest priority\r
 \r
         return MacroDict\r
 \r
         # Highest priority\r
 \r
         return MacroDict\r
 \r

-    def __EvaluateConditional(self, Expression, Line, Op = None, Value = None):\r
-        FileLineTuple = GetRealFileLine(self.FileName, Line)\r
-        MacroPcdDict = self.__CollectMacroPcd()\r
+    def _EvaluateConditional(self, Expression, Line, Op = None, Value = None):\r
+        MacroPcdDict = self._CollectMacroPcd()\r

         if Op == 'eval':\r
             try:\r
                 if Value:\r
                     return ValueExpression(Expression, MacroPcdDict)(True)\r
                 else:\r
                     return ValueExpression(Expression, MacroPcdDict)()\r
         if Op == 'eval':\r
             try:\r
                 if Value:\r
                     return ValueExpression(Expression, MacroPcdDict)(True)\r
                 else:\r
                     return ValueExpression(Expression, MacroPcdDict)()\r

-            except WrnExpression, Excpt:\r
-                # \r
+            except WrnExpression as Excpt:\r
+                #\r

                 # Catch expression evaluation warning here. We need to report\r
                 # the precise number of line and return the evaluation result\r
                 #\r
                 EdkLogger.warn('Parser', "Suspicious expression: %s" % str(Excpt),\r
                 # Catch expression evaluation warning here. We need to report\r
                 # the precise number of line and return the evaluation result\r
                 #\r
                 EdkLogger.warn('Parser', "Suspicious expression: %s" % str(Excpt),\r

-                                File=self.FileName, ExtraData=self.__CurrentLine(), \r
+                                File=self.FileName, ExtraData=self._CurrentLine(),\r

                                 Line=Line)\r
                 return Excpt.result\r
                                 Line=Line)\r
                 return Excpt.result\r

-            except Exception, Excpt:\r
+            except Exception as Excpt:\r

                 if hasattr(Excpt, 'Pcd'):\r
                     if Excpt.Pcd in GlobalData.gPlatformOtherPcds:\r
                         Info = GlobalData.gPlatformOtherPcds[Excpt.Pcd]\r
                 if hasattr(Excpt, 'Pcd'):\r
                     if Excpt.Pcd in GlobalData.gPlatformOtherPcds:\r
                         Info = GlobalData.gPlatformOtherPcds[Excpt.Pcd]\r


@@ -936,21 +896,21 @@ class FdfParser:
                                       " it must be defined in a [PcdsFixedAtBuild] or [PcdsFeatureFlag] section"\r
                                       " of the DSC file (%s), and it is currently defined in this section:"\r
                                       " %s, line #: %d." % (Excpt.Pcd, GlobalData.gPlatformOtherPcds['DSCFILE'], Info[0], Info[1]),\r
                                       " it must be defined in a [PcdsFixedAtBuild] or [PcdsFeatureFlag] section"\r
                                       " of the DSC file (%s), and it is currently defined in this section:"\r
                                       " %s, line #: %d." % (Excpt.Pcd, GlobalData.gPlatformOtherPcds['DSCFILE'], Info[0], Info[1]),\r

-                                      *FileLineTuple)\r
+                                      self.FileName, Line)\r

                     else:\r
                         raise Warning("PCD (%s) is not defined in DSC file (%s)" % (Excpt.Pcd, GlobalData.gPlatformOtherPcds['DSCFILE']),\r
                     else:\r
                         raise Warning("PCD (%s) is not defined in DSC file (%s)" % (Excpt.Pcd, GlobalData.gPlatformOtherPcds['DSCFILE']),\r

-                                      *FileLineTuple)\r
+                                      self.FileName, Line)\r

                 else:\r
                 else:\r

-                    raise Warning(str(Excpt), *FileLineTuple)\r
+                    raise Warning(str(Excpt), self.FileName, Line)\r

         else:\r
             if Expression.startswith('$(') and Expression[-1] == ')':\r
         else:\r
             if Expression.startswith('$(') and Expression[-1] == ')':\r

-                Expression = Expression[2:-1]            \r
+                Expression = Expression[2:-1]\r

             return Expression in MacroPcdDict\r
 \r
             return Expression in MacroPcdDict\r
 \r

-    ## __IsToken() method\r
+    ## _IsToken() method\r

     #\r
     #   Check whether input string is found from current char position along\r
     #\r
     #   Check whether input string is found from current char position along\r

-    #   If found, the string value is put into self.__Token\r
+    #   If found, the string value is put into self._Token\r

     #\r
     #   @param  self        The object pointer\r
     #   @param  String      The string to search\r
     #\r
     #   @param  self        The object pointer\r
     #   @param  String      The string to search\r


@@ -958,26 +918,26 @@ class FdfParser:
     #   @retval True        Successfully find string, file buffer pointer moved forward\r
     #   @retval False       Not able to find string, file buffer pointer not changed\r
     #\r
     #   @retval True        Successfully find string, file buffer pointer moved forward\r
     #   @retval False       Not able to find string, file buffer pointer not changed\r
     #\r

-    def __IsToken(self, String, IgnoreCase = False):\r
-        self.__SkipWhiteSpace()\r
+    def _IsToken(self, String, IgnoreCase = False):\r
+        self._SkipWhiteSpace()\r

 \r
         # Only consider the same line, no multi-line token allowed\r
         StartPos = self.CurrentOffsetWithinLine\r
         index = -1\r
         if IgnoreCase:\r
 \r
         # Only consider the same line, no multi-line token allowed\r
         StartPos = self.CurrentOffsetWithinLine\r
         index = -1\r
         if IgnoreCase:\r

-            index = self.__CurrentLine()[self.CurrentOffsetWithinLine : ].upper().find(String.upper())\r
+            index = self._CurrentLine()[self.CurrentOffsetWithinLine: ].upper().find(String.upper())\r

         else:\r
         else:\r

-            index = self.__CurrentLine()[self.CurrentOffsetWithinLine : ].find(String)\r
+            index = self._CurrentLine()[self.CurrentOffsetWithinLine: ].find(String)\r

         if index == 0:\r
             self.CurrentOffsetWithinLine += len(String)\r
         if index == 0:\r
             self.CurrentOffsetWithinLine += len(String)\r

-            self.__Token = self.__CurrentLine()[StartPos : self.CurrentOffsetWithinLine]\r
+            self._Token = self._CurrentLine()[StartPos: self.CurrentOffsetWithinLine]\r

             return True\r
         return False\r
 \r
             return True\r
         return False\r
 \r

-    ## __IsKeyword() method\r
+    ## _IsKeyword() method\r

     #\r
     #   Check whether input keyword is found from current char position along, whole word only!\r
     #\r
     #   Check whether input keyword is found from current char position along, whole word only!\r

-    #   If found, the string value is put into self.__Token\r
+    #   If found, the string value is put into self._Token\r

     #\r
     #   @param  self        The object pointer\r
     #   @param  Keyword     The string to search\r
     #\r
     #   @param  self        The object pointer\r
     #   @param  Keyword     The string to search\r


@@ -985,94 +945,117 @@ class FdfParser:
     #   @retval True        Successfully find string, file buffer pointer moved forward\r
     #   @retval False       Not able to find string, file buffer pointer not changed\r
     #\r
     #   @retval True        Successfully find string, file buffer pointer moved forward\r
     #   @retval False       Not able to find string, file buffer pointer not changed\r
     #\r

-    def __IsKeyword(self, KeyWord, IgnoreCase = False):\r
-        self.__SkipWhiteSpace()\r
+    def _IsKeyword(self, KeyWord, IgnoreCase = False):\r
+        self._SkipWhiteSpace()\r

 \r
         # Only consider the same line, no multi-line token allowed\r
         StartPos = self.CurrentOffsetWithinLine\r
         index = -1\r
         if IgnoreCase:\r
 \r
         # Only consider the same line, no multi-line token allowed\r
         StartPos = self.CurrentOffsetWithinLine\r
         index = -1\r
         if IgnoreCase:\r

-            index = self.__CurrentLine()[self.CurrentOffsetWithinLine : ].upper().find(KeyWord.upper())\r
+            index = self._CurrentLine()[self.CurrentOffsetWithinLine: ].upper().find(KeyWord.upper())\r

         else:\r
         else:\r

-            index = self.__CurrentLine()[self.CurrentOffsetWithinLine : ].find(KeyWord)\r
+            index = self._CurrentLine()[self.CurrentOffsetWithinLine: ].find(KeyWord)\r

         if index == 0:\r
         if index == 0:\r

-            followingChar = self.__CurrentLine()[self.CurrentOffsetWithinLine + len(KeyWord)]\r
-            if not str(followingChar).isspace() and followingChar not in SEPERATOR_TUPLE:\r
+            followingChar = self._CurrentLine()[self.CurrentOffsetWithinLine + len(KeyWord)]\r
+            if not str(followingChar).isspace() and followingChar not in SEPARATORS:\r

                 return False\r
             self.CurrentOffsetWithinLine += len(KeyWord)\r
                 return False\r
             self.CurrentOffsetWithinLine += len(KeyWord)\r

-            self.__Token = self.__CurrentLine()[StartPos : self.CurrentOffsetWithinLine]\r
+            self._Token = self._CurrentLine()[StartPos: self.CurrentOffsetWithinLine]\r

             return True\r
         return False\r
 \r
             return True\r
         return False\r
 \r

-    def __GetExpression(self):\r
+    def _GetExpression(self):\r

         Line = self.Profile.FileLinesList[self.CurrentLineNumber - 1]\r
         Index = len(Line) - 1\r
         Line = self.Profile.FileLinesList[self.CurrentLineNumber - 1]\r
         Index = len(Line) - 1\r

-        while Line[Index] in ['\r', '\n']:\r
+        while Line[Index] in CR_LB_SET:\r

             Index -= 1\r
         ExpressionString = self.Profile.FileLinesList[self.CurrentLineNumber - 1][self.CurrentOffsetWithinLine:Index+1]\r
         self.CurrentOffsetWithinLine += len(ExpressionString)\r
         ExpressionString = ExpressionString.strip()\r
         return ExpressionString\r
 \r
             Index -= 1\r
         ExpressionString = self.Profile.FileLinesList[self.CurrentLineNumber - 1][self.CurrentOffsetWithinLine:Index+1]\r
         self.CurrentOffsetWithinLine += len(ExpressionString)\r
         ExpressionString = ExpressionString.strip()\r
         return ExpressionString\r
 \r

-    ## __GetNextWord() method\r
+    ## _GetNextWord() method\r

     #\r
     #   Get next C name from file lines\r
     #\r
     #   Get next C name from file lines\r

-    #   If found, the string value is put into self.__Token\r
+    #   If found, the string value is put into self._Token\r

     #\r
     #   @param  self        The object pointer\r
     #   @retval True        Successfully find a C name string, file buffer pointer moved forward\r
     #   @retval False       Not able to find a C name string, file buffer pointer not changed\r
     #\r
     #\r
     #   @param  self        The object pointer\r
     #   @retval True        Successfully find a C name string, file buffer pointer moved forward\r
     #   @retval False       Not able to find a C name string, file buffer pointer not changed\r
     #\r

-    def __GetNextWord(self):\r
-        self.__SkipWhiteSpace()\r
-        if self.__EndOfFile():\r
+    def _GetNextWord(self):\r
+        self._SkipWhiteSpace()\r
+        if self._EndOfFile():\r

             return False\r
 \r
             return False\r
 \r

-        TempChar = self.__CurrentChar()\r
+        TempChar = self._CurrentChar()\r

         StartPos = self.CurrentOffsetWithinLine\r
         if (TempChar >= 'a' and TempChar <= 'z') or (TempChar >= 'A' and TempChar <= 'Z') or TempChar == '_':\r
         StartPos = self.CurrentOffsetWithinLine\r
         if (TempChar >= 'a' and TempChar <= 'z') or (TempChar >= 'A' and TempChar <= 'Z') or TempChar == '_':\r

-            self.__GetOneChar()\r
-            while not self.__EndOfLine():\r
-                TempChar = self.__CurrentChar()\r
+            self._GetOneChar()\r
+            while not self._EndOfLine():\r
+                TempChar = self._CurrentChar()\r

                 if (TempChar >= 'a' and TempChar <= 'z') or (TempChar >= 'A' and TempChar <= 'Z') \\r
                 or (TempChar >= '0' and TempChar <= '9') or TempChar == '_' or TempChar == '-':\r
                 if (TempChar >= 'a' and TempChar <= 'z') or (TempChar >= 'A' and TempChar <= 'Z') \\r
                 or (TempChar >= '0' and TempChar <= '9') or TempChar == '_' or TempChar == '-':\r

-                    self.__GetOneChar()\r
+                    self._GetOneChar()\r
+\r
+                else:\r
+                    break\r
+\r
+            self._Token = self._CurrentLine()[StartPos: self.CurrentOffsetWithinLine]\r
+            return True\r
+\r
+        return False\r
+\r
+    def _GetNextPcdWord(self):\r
+        self._SkipWhiteSpace()\r
+        if self._EndOfFile():\r
+            return False\r
+\r
+        TempChar = self._CurrentChar()\r
+        StartPos = self.CurrentOffsetWithinLine\r
+        if (TempChar >= 'a' and TempChar <= 'z') or (TempChar >= 'A' and TempChar <= 'Z') or TempChar == '_' or TempChar == TAB_SECTION_START or TempChar == TAB_SECTION_END:\r
+            self._GetOneChar()\r
+            while not self._EndOfLine():\r
+                TempChar = self._CurrentChar()\r
+                if (TempChar >= 'a' and TempChar <= 'z') or (TempChar >= 'A' and TempChar <= 'Z') \\r
+                or (TempChar >= '0' and TempChar <= '9') or TempChar == '_' or TempChar == '-' or TempChar == TAB_SECTION_START or TempChar == TAB_SECTION_END:\r
+                    self._GetOneChar()\r

 \r
                 else:\r
                     break\r
 \r
 \r
                 else:\r
                     break\r
 \r

-            self.__Token = self.__CurrentLine()[StartPos : self.CurrentOffsetWithinLine]\r
+            self._Token = self._CurrentLine()[StartPos: self.CurrentOffsetWithinLine]\r

             return True\r
 \r
         return False\r
 \r
             return True\r
 \r
         return False\r
 \r

-    ## __GetNextToken() method\r
+    ## _GetNextToken() method\r

     #\r
     #\r

-    #   Get next token unit before a seperator\r
-    #   If found, the string value is put into self.__Token\r
+    #   Get next token unit before a separator\r
+    #   If found, the string value is put into self._Token\r

     #\r
     #   @param  self        The object pointer\r
     #   @retval True        Successfully find a token unit, file buffer pointer moved forward\r
     #   @retval False       Not able to find a token unit, file buffer pointer not changed\r
     #\r
     #\r
     #   @param  self        The object pointer\r
     #   @retval True        Successfully find a token unit, file buffer pointer moved forward\r
     #   @retval False       Not able to find a token unit, file buffer pointer not changed\r
     #\r

-    def __GetNextToken(self):\r
+    def _GetNextToken(self):\r

         # Skip leading spaces, if exist.\r
         # Skip leading spaces, if exist.\r

-        self.__SkipWhiteSpace()\r
-        if self.__EndOfFile():\r
+        self._SkipWhiteSpace()\r
+        if self._EndOfFile():\r

             return False\r
         # Record the token start position, the position of the first non-space char.\r
         StartPos = self.CurrentOffsetWithinLine\r
         StartLine = self.CurrentLineNumber\r
         while StartLine == self.CurrentLineNumber:\r
             return False\r
         # Record the token start position, the position of the first non-space char.\r
         StartPos = self.CurrentOffsetWithinLine\r
         StartLine = self.CurrentLineNumber\r
         while StartLine == self.CurrentLineNumber:\r

-            TempChar = self.__CurrentChar()\r
-            # Try to find the end char that is not a space and not in seperator tuple.\r
+            TempChar = self._CurrentChar()\r
+            # Try to find the end char that is not a space and not in separator tuple.\r

             # That is, when we got a space or any char in the tuple, we got the end of token.\r
             # That is, when we got a space or any char in the tuple, we got the end of token.\r

-            if not str(TempChar).isspace() and TempChar not in SEPERATOR_TUPLE:\r
-                self.__GetOneChar()\r
-            # if we happen to meet a seperator as the first char, we must proceed to get it.\r
-            # That is, we get a token that is a seperator char. nomally it is the boundary of other tokens.\r
-            elif StartPos == self.CurrentOffsetWithinLine and TempChar in SEPERATOR_TUPLE:\r
-                self.__GetOneChar()\r
+            if not str(TempChar).isspace() and TempChar not in SEPARATORS:\r
+                self._GetOneChar()\r
+            # if we happen to meet a separator as the first char, we must proceed to get it.\r
+            # That is, we get a token that is a separator char. normally it is the boundary of other tokens.\r
+            elif StartPos == self.CurrentOffsetWithinLine and TempChar in SEPARATORS:\r
+                self._GetOneChar()\r

                 break\r
             else:\r
                 break\r
                 break\r
             else:\r
                 break\r


@@ -1082,81 +1065,60 @@ class FdfParser:
         EndPos = self.CurrentOffsetWithinLine\r
         if self.CurrentLineNumber != StartLine:\r
             EndPos = len(self.Profile.FileLinesList[StartLine-1])\r
         EndPos = self.CurrentOffsetWithinLine\r
         if self.CurrentLineNumber != StartLine:\r
             EndPos = len(self.Profile.FileLinesList[StartLine-1])\r

-        self.__Token = self.Profile.FileLinesList[StartLine-1][StartPos : EndPos]\r
+        self._Token = self.Profile.FileLinesList[StartLine-1][StartPos: EndPos]\r
+        if self._Token.lower() in {TAB_IF, TAB_END_IF, TAB_ELSE_IF, TAB_ELSE, TAB_IF_DEF, TAB_IF_N_DEF, TAB_ERROR, TAB_INCLUDE}:\r
+            self._Token = self._Token.lower()\r

         if StartPos != self.CurrentOffsetWithinLine:\r
             return True\r
         else:\r
             return False\r
 \r
         if StartPos != self.CurrentOffsetWithinLine:\r
             return True\r
         else:\r
             return False\r
 \r

-    def __GetNextOp(self):\r
-        # Skip leading spaces, if exist.\r
-        self.__SkipWhiteSpace()\r
-        if self.__EndOfFile():\r
-            return False\r
-        # Record the token start position, the position of the first non-space char.\r
-        StartPos = self.CurrentOffsetWithinLine\r
-        while not self.__EndOfLine():\r
-            TempChar = self.__CurrentChar()\r
-            # Try to find the end char that is not a space\r
-            if not str(TempChar).isspace():\r
-                self.__GetOneChar()\r
-            else:\r
-                break\r
-        else:\r
-            return False\r
-\r
-        if StartPos != self.CurrentOffsetWithinLine:\r
-            self.__Token = self.__CurrentLine()[StartPos : self.CurrentOffsetWithinLine]\r
-            return True\r
-        else:\r
-            return False\r
-    ## __GetNextGuid() method\r
+    ## _GetNextGuid() method\r

     #\r
     #\r

-    #   Get next token unit before a seperator\r
-    #   If found, the GUID string is put into self.__Token\r
+    #   Get next token unit before a separator\r
+    #   If found, the GUID string is put into self._Token\r

     #\r
     #   @param  self        The object pointer\r
     #   @retval True        Successfully find a registry format GUID, file buffer pointer moved forward\r
     #   @retval False       Not able to find a registry format GUID, file buffer pointer not changed\r
     #\r
     #\r
     #   @param  self        The object pointer\r
     #   @retval True        Successfully find a registry format GUID, file buffer pointer moved forward\r
     #   @retval False       Not able to find a registry format GUID, file buffer pointer not changed\r
     #\r

-    def __GetNextGuid(self):\r
-\r
-        if not self.__GetNextToken():\r
+    def _GetNextGuid(self):\r
+        if not self._GetNextToken():\r

             return False\r
             return False\r

-        if gGuidPattern.match(self.__Token) is not None:\r
+        if GlobalData.gGuidPattern.match(self._Token) is not None:\r

             return True\r
         else:\r
             return True\r
         else:\r

-            self.__UndoToken()\r
+            self._UndoToken()\r

             return False\r
 \r
             return False\r
 \r

-    def __Verify(self, Name, Value, Scope):\r
-        if Scope in ['UINT64', 'UINT8']:\r
-            ValueNumber = 0\r
-            try:\r
-                ValueNumber = int (Value, 0)\r
-            except:\r
-                EdkLogger.error("FdfParser", FORMAT_INVALID, "The value is not valid dec or hex number for %s." % Name)\r
-            if ValueNumber < 0:\r
-                EdkLogger.error("FdfParser", FORMAT_INVALID, "The value can't be set to negative value for %s." % Name)\r
-            if Scope == 'UINT64':\r
-                if ValueNumber >= 0x10000000000000000:\r
-                    EdkLogger.error("FdfParser", FORMAT_INVALID, "Too large value for %s." % Name)\r
-            if Scope == 'UINT8':\r
-                if ValueNumber >= 0x100:\r
-                    EdkLogger.error("FdfParser", FORMAT_INVALID, "Too large value for %s." % Name)\r
-            return True\r
+    @staticmethod\r
+    def _Verify(Name, Value, Scope):\r
+        # value verification only applies to numeric values.\r
+        if Scope not in TAB_PCD_NUMERIC_TYPES:\r
+            return\r
+\r
+        ValueNumber = 0\r
+        try:\r
+            ValueNumber = int(Value, 0)\r
+        except:\r
+            EdkLogger.error("FdfParser", FORMAT_INVALID, "The value is not valid dec or hex number for %s." % Name)\r
+        if ValueNumber < 0:\r
+            EdkLogger.error("FdfParser", FORMAT_INVALID, "The value can't be set to negative value for %s." % Name)\r
+        if ValueNumber > MAX_VAL_TYPE[Scope]:\r
+            EdkLogger.error("FdfParser", FORMAT_INVALID, "Too large value for %s." % Name)\r
+        return True\r

 \r
 \r

-    ## __UndoToken() method\r
+    ## _UndoToken() method\r

     #\r
     #   Go back one token unit in file buffer\r
     #\r
     #   @param  self        The object pointer\r
     #\r
     #\r
     #   Go back one token unit in file buffer\r
     #\r
     #   @param  self        The object pointer\r
     #\r

-    def __UndoToken(self):\r
-        self.__UndoOneChar()\r
-        while self.__CurrentChar().isspace():\r
-            if not self.__UndoOneChar():\r
-                self.__GetOneChar()\r
+    def _UndoToken(self):\r
+        self._UndoOneChar()\r
+        while self._CurrentChar().isspace():\r
+            if not self._UndoOneChar():\r
+                self._GetOneChar()\r

                 return\r
 \r
 \r
                 return\r
 \r
 \r


@@ -1164,127 +1126,110 @@ class FdfParser:
         CurrentLine = self.CurrentLineNumber\r
         while CurrentLine == self.CurrentLineNumber:\r
 \r
         CurrentLine = self.CurrentLineNumber\r
         while CurrentLine == self.CurrentLineNumber:\r
 \r

-            TempChar = self.__CurrentChar()\r
-            # Try to find the end char that is not a space and not in seperator tuple.\r
+            TempChar = self._CurrentChar()\r
+            # Try to find the end char that is not a space and not in separator tuple.\r

             # That is, when we got a space or any char in the tuple, we got the end of token.\r
             # That is, when we got a space or any char in the tuple, we got the end of token.\r

-            if not str(TempChar).isspace() and not TempChar in SEPERATOR_TUPLE:\r
-                if not self.__UndoOneChar():\r
+            if not str(TempChar).isspace() and not TempChar in SEPARATORS:\r
+                if not self._UndoOneChar():\r

                     return\r
                     return\r

-            # if we happen to meet a seperator as the first char, we must proceed to get it.\r
-            # That is, we get a token that is a seperator char. nomally it is the boundary of other tokens.\r
-            elif StartPos == self.CurrentOffsetWithinLine and TempChar in SEPERATOR_TUPLE:\r
+            # if we happen to meet a separator as the first char, we must proceed to get it.\r
+            # That is, we get a token that is a separator char. normally it is the boundary of other tokens.\r
+            elif StartPos == self.CurrentOffsetWithinLine and TempChar in SEPARATORS:\r

                 return\r
             else:\r
                 break\r
 \r
                 return\r
             else:\r
                 break\r
 \r

-        self.__GetOneChar()\r
+        self._GetOneChar()\r

 \r
 \r

-    def __IsHex(self, HexStr):\r
-        if not HexStr.upper().startswith("0X"):\r
-            return False\r
-        if len(self.__Token) <= 2:\r
-            return False\r
-        return True if all(x in string.hexdigits for x in HexStr[2:]) else False\r
-\r
-    ## __GetNextHexNumber() method\r
+    ## _GetNextHexNumber() method\r

     #\r
     #\r

-    #   Get next HEX data before a seperator\r
-    #   If found, the HEX data is put into self.__Token\r
+    #   Get next HEX data before a separator\r
+    #   If found, the HEX data is put into self._Token\r

     #\r
     #   @param  self        The object pointer\r
     #   @retval True        Successfully find a HEX data, file buffer pointer moved forward\r
     #   @retval False       Not able to find a HEX data, file buffer pointer not changed\r
     #\r
     #\r
     #   @param  self        The object pointer\r
     #   @retval True        Successfully find a HEX data, file buffer pointer moved forward\r
     #   @retval False       Not able to find a HEX data, file buffer pointer not changed\r
     #\r

-    def __GetNextHexNumber(self):\r
-        if not self.__GetNextToken():\r
+    def _GetNextHexNumber(self):\r
+        if not self._GetNextToken():\r

             return False\r
             return False\r

-        if self.__IsHex(self.__Token):\r
+        if GlobalData.gHexPatternAll.match(self._Token):\r

             return True\r
         else:\r
             return True\r
         else:\r

-            self.__UndoToken()\r
+            self._UndoToken()\r

             return False\r
 \r
             return False\r
 \r

-    ## __GetNextDecimalNumber() method\r
+    ## _GetNextDecimalNumber() method\r

     #\r
     #\r

-    #   Get next decimal data before a seperator\r
-    #   If found, the decimal data is put into self.__Token\r
+    #   Get next decimal data before a separator\r
+    #   If found, the decimal data is put into self._Token\r

     #\r
     #   @param  self        The object pointer\r
     #   @retval True        Successfully find a decimal data, file buffer pointer moved forward\r
     #   @retval False       Not able to find a decimal data, file buffer pointer not changed\r
     #\r
     #\r
     #   @param  self        The object pointer\r
     #   @retval True        Successfully find a decimal data, file buffer pointer moved forward\r
     #   @retval False       Not able to find a decimal data, file buffer pointer not changed\r
     #\r

-    def __GetNextDecimalNumber(self):\r
-        if not self.__GetNextToken():\r
+    def _GetNextDecimalNumber(self):\r
+        if not self._GetNextToken():\r

             return False\r
             return False\r

-        if self.__Token.isdigit():\r
+        if self._Token.isdigit():\r

             return True\r
         else:\r
             return True\r
         else:\r

-            self.__UndoToken()\r
+            self._UndoToken()\r

             return False\r
 \r
             return False\r
 \r

-    ## __GetNextPcdName() method\r
-    #\r
-    #   Get next PCD token space C name and PCD C name pair before a seperator\r
-    #   If found, the decimal data is put into self.__Token\r
-    #\r
-    #   @param  self        The object pointer\r
-    #   @retval Tuple       PCD C name and PCD token space C name pair\r
-    #\r
-    def __GetNextPcdName(self):\r
-        if not self.__GetNextWord():\r
-            raise Warning("expected format of <PcdTokenSpaceCName>.<PcdCName>", self.FileName, self.CurrentLineNumber)\r
-        pcdTokenSpaceCName = self.__Token\r
+    def _GetNextPcdSettings(self):\r
+        if not self._GetNextWord():\r
+            raise Warning.Expected("<PcdTokenSpaceCName>", self.FileName, self.CurrentLineNumber)\r
+        pcdTokenSpaceCName = self._Token\r

 \r
 \r

-        if not self.__IsToken( "."):\r
-            raise Warning("expected format of <PcdTokenSpaceCName>.<PcdCName>", self.FileName, self.CurrentLineNumber)\r
+        if not self._IsToken(TAB_SPLIT):\r
+            raise Warning.Expected(".", self.FileName, self.CurrentLineNumber)\r

 \r
 \r

-        if not self.__GetNextWord():\r
-            raise Warning("expected format of <PcdTokenSpaceCName>.<PcdCName>", self.FileName, self.CurrentLineNumber)\r
-        pcdCName = self.__Token\r
+        if not self._GetNextWord():\r
+            raise Warning.Expected("<PcdCName>", self.FileName, self.CurrentLineNumber)\r
+        pcdCName = self._Token\r

 \r
 \r

-        return (pcdCName, pcdTokenSpaceCName)\r
+        Fields = []\r
+        while self._IsToken(TAB_SPLIT):\r
+            if not self._GetNextPcdWord():\r
+                raise Warning.Expected("Pcd Fields", self.FileName, self.CurrentLineNumber)\r
+            Fields.append(self._Token)\r

 \r
 \r

-    ## __GetStringData() method\r
+        return (pcdCName, pcdTokenSpaceCName,TAB_SPLIT.join(Fields))\r
+\r
+    ## _GetStringData() method\r

     #\r
     #   Get string contents quoted in ""\r
     #\r
     #   Get string contents quoted in ""\r

-    #   If found, the decimal data is put into self.__Token\r
+    #   If found, the decimal data is put into self._Token\r

     #\r
     #   @param  self        The object pointer\r
     #   @retval True        Successfully find a string data, file buffer pointer moved forward\r
     #   @retval False       Not able to find a string data, file buffer pointer not changed\r
     #\r
     #\r
     #   @param  self        The object pointer\r
     #   @retval True        Successfully find a string data, file buffer pointer moved forward\r
     #   @retval False       Not able to find a string data, file buffer pointer not changed\r
     #\r

-    def __GetStringData(self):\r
-        if self.__Token.startswith("\"") or self.__Token.startswith("L\""):\r
-            self.__UndoToken()\r
-            self.__SkipToToken("\"")\r
-            currentLineNumber = self.CurrentLineNumber\r
-\r
-            if not self.__SkipToToken("\""):\r
-                raise Warning("Missing Quote \" for String", self.FileName, self.CurrentLineNumber)\r
-            if currentLineNumber != self.CurrentLineNumber:\r
-                raise Warning("Missing Quote \" for String", self.FileName, self.CurrentLineNumber)\r
-            self.__Token = self.__SkippedChars.rstrip('\"')\r
-            return True\r
-\r
-        elif self.__Token.startswith("\'") or self.__Token.startswith("L\'"):\r
-            self.__UndoToken()\r
-            self.__SkipToToken("\'")\r
-            currentLineNumber = self.CurrentLineNumber\r
-\r
-            if not self.__SkipToToken("\'"):\r
-                raise Warning("Missing Quote \' for String", self.FileName, self.CurrentLineNumber)\r
-            if currentLineNumber != self.CurrentLineNumber:\r
-                raise Warning("Missing Quote \' for String", self.FileName, self.CurrentLineNumber)\r
-            self.__Token = self.__SkippedChars.rstrip('\'')\r
-            return True\r
-\r
+    def _GetStringData(self):\r
+        QuoteToUse = None\r
+        if self._Token.startswith(T_CHAR_DOUBLE_QUOTE) or self._Token.startswith("L\""):\r
+            QuoteToUse = T_CHAR_DOUBLE_QUOTE\r
+        elif self._Token.startswith(T_CHAR_SINGLE_QUOTE) or self._Token.startswith("L\'"):\r
+            QuoteToUse = T_CHAR_SINGLE_QUOTE\r

         else:\r
             return False\r
 \r
         else:\r
             return False\r
 \r

-    ## __SkipToToken() method\r
+        self._UndoToken()\r
+        self._SkipToToken(QuoteToUse)\r
+        currentLineNumber = self.CurrentLineNumber\r
+\r
+        if not self._SkipToToken(QuoteToUse):\r
+            raise Warning(QuoteToUse, self.FileName, self.CurrentLineNumber)\r
+        if currentLineNumber != self.CurrentLineNumber:\r
+            raise Warning(QuoteToUse, self.FileName, self.CurrentLineNumber)\r
+        self._Token = self._SkippedChars.rstrip(QuoteToUse)\r
+        return True\r
+\r
+    ## _SkipToToken() method\r

     #\r
     #   Search forward in file buffer for the string\r
     #\r
     #   Search forward in file buffer for the string\r

-    #   The skipped chars are put into self.__SkippedChars\r
+    #   The skipped chars are put into self._SkippedChars\r

     #\r
     #   @param  self        The object pointer\r
     #   @param  String      The string to search\r
     #\r
     #   @param  self        The object pointer\r
     #   @param  String      The string to search\r


@@ -1292,25 +1237,25 @@ class FdfParser:
     #   @retval True        Successfully find the string, file buffer pointer moved forward\r
     #   @retval False       Not able to find the string, file buffer pointer not changed\r
     #\r
     #   @retval True        Successfully find the string, file buffer pointer moved forward\r
     #   @retval False       Not able to find the string, file buffer pointer not changed\r
     #\r

-    def __SkipToToken(self, String, IgnoreCase = False):\r
+    def _SkipToToken(self, String, IgnoreCase = False):\r

         StartPos = self.GetFileBufferPos()\r
 \r
         StartPos = self.GetFileBufferPos()\r
 \r

-        self.__SkippedChars = ""\r
-        while not self.__EndOfFile():\r
+        self._SkippedChars = ""\r
+        while not self._EndOfFile():\r

             index = -1\r
             if IgnoreCase:\r
             index = -1\r
             if IgnoreCase:\r

-                index = self.__CurrentLine()[self.CurrentOffsetWithinLine : ].upper().find(String.upper())\r
+                index = self._CurrentLine()[self.CurrentOffsetWithinLine: ].upper().find(String.upper())\r

             else:\r
             else:\r

-                index = self.__CurrentLine()[self.CurrentOffsetWithinLine : ].find(String)\r
+                index = self._CurrentLine()[self.CurrentOffsetWithinLine: ].find(String)\r

             if index == 0:\r
                 self.CurrentOffsetWithinLine += len(String)\r
             if index == 0:\r
                 self.CurrentOffsetWithinLine += len(String)\r

-                self.__SkippedChars += String\r
+                self._SkippedChars += String\r

                 return True\r
                 return True\r

-            self.__SkippedChars += str(self.__CurrentChar())\r
-            self.__GetOneChar()\r
+            self._SkippedChars += str(self._CurrentChar())\r
+            self._GetOneChar()\r

 \r
 \r

-        self.SetFileBufferPos( StartPos)\r
-        self.__SkippedChars = ""\r
+        self.SetFileBufferPos(StartPos)\r
+        self._SkippedChars = ""\r

         return False\r
 \r
     ## GetFileBufferPos() method\r
         return False\r
 \r
     ## GetFileBufferPos() method\r


@@ -1341,18 +1286,18 @@ class FdfParser:
     #   @param  self        The object pointer\r
     #\r
     def Preprocess(self):\r
     #   @param  self        The object pointer\r
     #\r
     def Preprocess(self):\r

-        self.__StringToList()\r
+        self._StringToList()\r

         self.PreprocessFile()\r
         self.PreprocessIncludeFile()\r
         self.PreprocessFile()\r
         self.PreprocessIncludeFile()\r

-        self.__StringToList()\r
+        self._StringToList()\r

         self.PreprocessFile()\r
         self.PreprocessConditionalStatement()\r
         self.PreprocessFile()\r
         self.PreprocessConditionalStatement()\r

-        self.__StringToList()\r
-        for Pos in self.__WipeOffArea:\r
-            self.__ReplaceFragment(Pos[0], Pos[1])\r
+        self._StringToList()\r
+        for Pos in self._WipeOffArea:\r
+            self._ReplaceFragment(Pos[0], Pos[1])\r

         self.Profile.FileLinesList = ["".join(list) for list in self.Profile.FileLinesList]\r
 \r
         self.Profile.FileLinesList = ["".join(list) for list in self.Profile.FileLinesList]\r
 \r

-        while self.__GetDefines():\r
+        while self._GetDefines():\r

             pass\r
 \r
     ## ParseFile() method\r
             pass\r
 \r
     ## ParseFile() method\r


@@ -1363,18 +1308,18 @@ class FdfParser:
     #   @param  self        The object pointer\r
     #\r
     def ParseFile(self):\r
     #   @param  self        The object pointer\r
     #\r
     def ParseFile(self):\r

-\r

         try:\r
             self.Preprocess()\r
         try:\r
             self.Preprocess()\r

+            self._GetError()\r

             #\r
             # Keep processing sections of the FDF until no new sections or a syntax error is found\r
             #\r
             #\r
             # Keep processing sections of the FDF until no new sections or a syntax error is found\r
             #\r

-            while self.__GetFd() or self.__GetFv() or self.__GetFmp() or self.__GetCapsule() or self.__GetVtf() or self.__GetRule() or self.__GetOptionRom():\r
+            while self._GetFd() or self._GetFv() or self._GetFmp() or self._GetCapsule() or self._GetRule() or self._GetOptionRom():\r

                 pass\r
 \r
                 pass\r
 \r

-        except Warning, X:\r
-            self.__UndoToken()\r
-            #'\n\tGot Token: \"%s\" from File %s\n' % (self.__Token, FileLineTuple[0]) + \\r
+        except Warning as X:\r
+            self._UndoToken()\r
+            #'\n\tGot Token: \"%s\" from File %s\n' % (self._Token, FileLineTuple[0]) + \\r

             # At this point, the closest parent would be the included file itself\r
             Profile = GetParentAtLine(X.OriginalLineNumber)\r
             if Profile is not None:\r
             # At this point, the closest parent would be the included file itself\r
             Profile = GetParentAtLine(X.OriginalLineNumber)\r
             if Profile is not None:\r


@@ -1383,7 +1328,7 @@ class FdfParser:
             else:\r
                 FileLineTuple = GetRealFileLine(self.FileName, self.CurrentLineNumber)\r
                 X.Message += ' near line %d, column %d: %s' \\r
             else:\r
                 FileLineTuple = GetRealFileLine(self.FileName, self.CurrentLineNumber)\r
                 X.Message += ' near line %d, column %d: %s' \\r

-                % (FileLineTuple[1], self.CurrentOffsetWithinLine + 1, self.Profile.FileLinesList[self.CurrentLineNumber - 1][self.CurrentOffsetWithinLine :].rstrip('\n').rstrip('\r'))\r
+                % (FileLineTuple[1], self.CurrentOffsetWithinLine + 1, self.Profile.FileLinesList[self.CurrentLineNumber - 1][self.CurrentOffsetWithinLine:].rstrip(TAB_LINE_BREAK).rstrip(T_CHAR_CR))\r

             raise\r
 \r
     ## SectionParser() method\r
             raise\r
 \r
     ## SectionParser() method\r


@@ -1397,10 +1342,10 @@ class FdfParser:
     def SectionParser(self, section):\r
         S = section.upper()\r
         if not S.startswith("[DEFINES") and not S.startswith("[FD.") and not S.startswith("[FV.") and not S.startswith("[CAPSULE.") \\r
     def SectionParser(self, section):\r
         S = section.upper()\r
         if not S.startswith("[DEFINES") and not S.startswith("[FD.") and not S.startswith("[FV.") and not S.startswith("[CAPSULE.") \\r

-            and not S.startswith("[VTF.") and not S.startswith("[RULE.") and not S.startswith("[OPTIONROM.") and not S.startswith('[FMPPAYLOAD.'):\r
-            raise Warning("Unknown section or section appear sequence error (The correct sequence should be [DEFINES], [FD.], [FV.], [Capsule.], [VTF.], [Rule.], [OptionRom.], [FMPPAYLOAD.])", self.FileName, self.CurrentLineNumber)\r
+             and not S.startswith("[RULE.") and not S.startswith("[OPTIONROM.") and not S.startswith('[FMPPAYLOAD.'):\r
+            raise Warning("Unknown section or section appear sequence error (The correct sequence should be [DEFINES], [FD.], [FV.], [Capsule.], [Rule.], [OptionRom.], [FMPPAYLOAD.])", self.FileName, self.CurrentLineNumber)\r

 \r
 \r

-    ## __GetDefines() method\r
+    ## _GetDefines() method\r

     #\r
     #   Get Defines section contents and store its data into AllMacrosList\r
     #\r
     #\r
     #   Get Defines section contents and store its data into AllMacrosList\r
     #\r


@@ -1408,45 +1353,55 @@ class FdfParser:
     #   @retval True        Successfully find a Defines\r
     #   @retval False       Not able to find a Defines\r
     #\r
     #   @retval True        Successfully find a Defines\r
     #   @retval False       Not able to find a Defines\r
     #\r

-    def __GetDefines(self):\r
-\r
-        if not self.__GetNextToken():\r
+    def _GetDefines(self):\r
+        if not self._GetNextToken():\r

             return False\r
 \r
             return False\r
 \r

-        S = self.__Token.upper()\r
-        if S.startswith("[") and not S.startswith("[DEFINES"):\r
+        S = self._Token.upper()\r
+        if S.startswith(TAB_SECTION_START) and not S.startswith("[DEFINES"):\r

             self.SectionParser(S)\r
             self.SectionParser(S)\r

-            self.__UndoToken()\r
+            self._UndoToken()\r

             return False\r
 \r
             return False\r
 \r

-        self.__UndoToken()\r
-        if not self.__IsToken("[DEFINES", True):\r
+        self._UndoToken()\r
+        if not self._IsToken("[DEFINES", True):\r

             FileLineTuple = GetRealFileLine(self.FileName, self.CurrentLineNumber)\r
             #print 'Parsing String: %s in File %s, At line: %d, Offset Within Line: %d' \\r
             FileLineTuple = GetRealFileLine(self.FileName, self.CurrentLineNumber)\r
             #print 'Parsing String: %s in File %s, At line: %d, Offset Within Line: %d' \\r

-            #        % (self.Profile.FileLinesList[self.CurrentLineNumber - 1][self.CurrentOffsetWithinLine :], FileLineTuple[0], FileLineTuple[1], self.CurrentOffsetWithinLine)\r
-            raise Warning("expected [DEFINES", self.FileName, self.CurrentLineNumber)\r
+            #        % (self.Profile.FileLinesList[self.CurrentLineNumber - 1][self.CurrentOffsetWithinLine:], FileLineTuple[0], FileLineTuple[1], self.CurrentOffsetWithinLine)\r
+            raise Warning.Expected("[DEFINES", self.FileName, self.CurrentLineNumber)\r

 \r
 \r

-        if not self.__IsToken( "]"):\r
-            raise Warning("expected ']'", self.FileName, self.CurrentLineNumber)\r
+        if not self._IsToken(TAB_SECTION_END):\r
+            raise Warning.ExpectedBracketClose(self.FileName, self.CurrentLineNumber)\r

 \r
 \r

-        while self.__GetNextWord():\r
+        while self._GetNextWord():\r

             # handle the SET statement\r
             # handle the SET statement\r

-            if self.__Token == 'SET':\r
-                self.__UndoToken()\r
-                self.__GetSetStatement(None)\r
+            if self._Token == 'SET':\r
+                self._UndoToken()\r
+                self._GetSetStatement(None)\r

                 continue\r
                 continue\r

-            \r
-            Macro = self.__Token\r
-            \r
-            if not self.__IsToken("="):\r
-                raise Warning("expected '='", self.FileName, self.CurrentLineNumber)\r
-            if not self.__GetNextToken() or self.__Token.startswith('['):\r
-                raise Warning("expected MACRO value", self.FileName, self.CurrentLineNumber)\r
-            Value = self.__Token\r
+\r
+            Macro = self._Token\r
+\r
+            if not self._IsToken(TAB_EQUAL_SPLIT):\r
+                raise Warning.ExpectedEquals(self.FileName, self.CurrentLineNumber)\r
+            if not self._GetNextToken() or self._Token.startswith(TAB_SECTION_START):\r
+                raise Warning.Expected("MACRO value", self.FileName, self.CurrentLineNumber)\r
+            Value = self._Token\r

 \r
         return False\r
 \r
 \r
         return False\r
 \r

-    ## __GetFd() method\r
+    ##_GetError() method\r
+    def _GetError(self):\r
+        #save the Current information\r
+        CurrentLine = self.CurrentLineNumber\r
+        CurrentOffset = self.CurrentOffsetWithinLine\r
+        while self._GetNextToken():\r
+            if self._Token == TAB_ERROR:\r
+                EdkLogger.error('FdfParser', ERROR_STATEMENT, self._CurrentLine().replace(TAB_ERROR, '', 1), File=self.FileName, Line=self.CurrentLineNumber)\r
+        self.CurrentLineNumber = CurrentLine\r
+        self.CurrentOffsetWithinLine = CurrentOffset\r
+\r
+    ## _GetFd() method\r

     #\r
     #   Get FD section contents and store its data into FD dictionary of self.Profile\r
     #\r
     #\r
     #   Get FD section contents and store its data into FD dictionary of self.Profile\r
     #\r


@@ -1454,27 +1409,26 @@ class FdfParser:
     #   @retval True        Successfully find a FD\r
     #   @retval False       Not able to find a FD\r
     #\r
     #   @retval True        Successfully find a FD\r
     #   @retval False       Not able to find a FD\r
     #\r

-    def __GetFd(self):\r
-\r
-        if not self.__GetNextToken():\r
+    def _GetFd(self):\r
+        if not self._GetNextToken():\r

             return False\r
 \r
             return False\r
 \r

-        S = self.__Token.upper()\r
-        if S.startswith("[") and not S.startswith("[FD."):\r
+        S = self._Token.upper()\r
+        if S.startswith(TAB_SECTION_START) and not S.startswith("[FD."):\r

             if not S.startswith("[FV.") and not S.startswith('[FMPPAYLOAD.') and not S.startswith("[CAPSULE.") \\r
             if not S.startswith("[FV.") and not S.startswith('[FMPPAYLOAD.') and not S.startswith("[CAPSULE.") \\r

-                and not S.startswith("[VTF.") and not S.startswith("[RULE.") and not S.startswith("[OPTIONROM."):\r
+                and not S.startswith("[RULE.") and not S.startswith("[OPTIONROM."):\r

                 raise Warning("Unknown section", self.FileName, self.CurrentLineNumber)\r
                 raise Warning("Unknown section", self.FileName, self.CurrentLineNumber)\r

-            self.__UndoToken()\r
+            self._UndoToken()\r

             return False\r
 \r
             return False\r
 \r

-        self.__UndoToken()\r
-        if not self.__IsToken("[FD.", True):\r
+        self._UndoToken()\r
+        if not self._IsToken("[FD.", True):\r

             FileLineTuple = GetRealFileLine(self.FileName, self.CurrentLineNumber)\r
             #print 'Parsing String: %s in File %s, At line: %d, Offset Within Line: %d' \\r
             FileLineTuple = GetRealFileLine(self.FileName, self.CurrentLineNumber)\r
             #print 'Parsing String: %s in File %s, At line: %d, Offset Within Line: %d' \\r

-            #        % (self.Profile.FileLinesList[self.CurrentLineNumber - 1][self.CurrentOffsetWithinLine :], FileLineTuple[0], FileLineTuple[1], self.CurrentOffsetWithinLine)\r
-            raise Warning("expected [FD.]", self.FileName, self.CurrentLineNumber)\r
+            #        % (self.Profile.FileLinesList[self.CurrentLineNumber - 1][self.CurrentOffsetWithinLine:], FileLineTuple[0], FileLineTuple[1], self.CurrentOffsetWithinLine)\r
+            raise Warning.Expected("[FD.]", self.FileName, self.CurrentLineNumber)\r

 \r
 \r

-        FdName = self.__GetUiName()\r
+        FdName = self._GetUiName()\r

         if FdName == "":\r
             if len (self.Profile.FdDict) == 0:\r
                 FdName = GenFdsGlobalVariable.PlatformName\r
         if FdName == "":\r
             if len (self.Profile.FdDict) == 0:\r
                 FdName = GenFdsGlobalVariable.PlatformName\r


@@ -1482,62 +1436,62 @@ class FdfParser:
                     FdName = GlobalData.gActivePlatform.PlatformName\r
                 self.Profile.FdNameNotSet = True\r
             else:\r
                     FdName = GlobalData.gActivePlatform.PlatformName\r
                 self.Profile.FdNameNotSet = True\r
             else:\r

-                raise Warning("expected FdName in [FD.] section", self.FileName, self.CurrentLineNumber)\r
+                raise Warning.Expected("FdName in [FD.] section", self.FileName, self.CurrentLineNumber)\r

         self.CurrentFdName = FdName.upper()\r
         self.CurrentFdName = FdName.upper()\r

-        \r
+\r

         if self.CurrentFdName in self.Profile.FdDict:\r
             raise Warning("Unexpected the same FD name", self.FileName, self.CurrentLineNumber)\r
 \r
         if self.CurrentFdName in self.Profile.FdDict:\r
             raise Warning("Unexpected the same FD name", self.FileName, self.CurrentLineNumber)\r
 \r

-        if not self.__IsToken( "]"):\r
-            raise Warning("expected ']'", self.FileName, self.CurrentLineNumber)\r
+        if not self._IsToken(TAB_SECTION_END):\r
+            raise Warning.ExpectedBracketClose(self.FileName, self.CurrentLineNumber)\r

 \r
 \r

-        FdObj = Fd.FD()\r
+        FdObj = FD()\r

         FdObj.FdUiName = self.CurrentFdName\r
         self.Profile.FdDict[self.CurrentFdName] = FdObj\r
 \r
         if len (self.Profile.FdDict) > 1 and self.Profile.FdNameNotSet:\r
         FdObj.FdUiName = self.CurrentFdName\r
         self.Profile.FdDict[self.CurrentFdName] = FdObj\r
 \r
         if len (self.Profile.FdDict) > 1 and self.Profile.FdNameNotSet:\r

-            raise Warning("expected all FDs have their name", self.FileName, self.CurrentLineNumber)\r
+            raise Warning.Expected("all FDs have their name", self.FileName, self.CurrentLineNumber)\r

 \r
 \r

-        Status = self.__GetCreateFile(FdObj)\r
+        Status = self._GetCreateFile(FdObj)\r

         if not Status:\r
             raise Warning("FD name error", self.FileName, self.CurrentLineNumber)\r
 \r
         if not Status:\r
             raise Warning("FD name error", self.FileName, self.CurrentLineNumber)\r
 \r

-        while self.__GetTokenStatements(FdObj):\r
+        while self._GetTokenStatements(FdObj):\r

             pass\r
         for Attr in ("BaseAddress", "Size", "ErasePolarity"):\r
             if getattr(FdObj, Attr) is None:\r
             pass\r
         for Attr in ("BaseAddress", "Size", "ErasePolarity"):\r
             if getattr(FdObj, Attr) is None:\r

-                self.__GetNextToken()\r
+                self._GetNextToken()\r

                 raise Warning("Keyword %s missing" % Attr, self.FileName, self.CurrentLineNumber)\r
 \r
         if not FdObj.BlockSizeList:\r
             FdObj.BlockSizeList.append((1, FdObj.Size, None))\r
 \r
                 raise Warning("Keyword %s missing" % Attr, self.FileName, self.CurrentLineNumber)\r
 \r
         if not FdObj.BlockSizeList:\r
             FdObj.BlockSizeList.append((1, FdObj.Size, None))\r
 \r

-        self.__GetDefineStatements(FdObj)\r
+        self._GetDefineStatements(FdObj)\r

 \r
 \r

-        self.__GetSetStatements(FdObj)\r
+        self._GetSetStatements(FdObj)\r

 \r
 \r

-        if not self.__GetRegionLayout(FdObj):\r
-            raise Warning("expected region layout", self.FileName, self.CurrentLineNumber)\r
+        if not self._GetRegionLayout(FdObj):\r
+            raise Warning.Expected("region layout", self.FileName, self.CurrentLineNumber)\r

 \r
 \r

-        while self.__GetRegionLayout(FdObj):\r
+        while self._GetRegionLayout(FdObj):\r

             pass\r
         return True\r
 \r
             pass\r
         return True\r
 \r

-    ## __GetUiName() method\r
+    ## _GetUiName() method\r

     #\r
     #   Return the UI name of a section\r
     #\r
     #   @param  self        The object pointer\r
     #   @retval FdName      UI name\r
     #\r
     #\r
     #   Return the UI name of a section\r
     #\r
     #   @param  self        The object pointer\r
     #   @retval FdName      UI name\r
     #\r

-    def __GetUiName(self):\r
+    def _GetUiName(self):\r

         Name = ""\r
         Name = ""\r

-        if self.__GetNextWord():\r
-            Name = self.__Token\r
+        if self._GetNextWord():\r
+            Name = self._Token\r

 \r
         return Name\r
 \r
 \r
         return Name\r
 \r

-    ## __GetCreateFile() method\r
+    ## _GetCreateFile() method\r

     #\r
     #   Return the output file name of object\r
     #\r
     #\r
     #   Return the output file name of object\r
     #\r


@@ -1545,78 +1499,82 @@ class FdfParser:
     #   @param  Obj         object whose data will be stored in file\r
     #   @retval FdName      UI name\r
     #\r
     #   @param  Obj         object whose data will be stored in file\r
     #   @retval FdName      UI name\r
     #\r

-    def __GetCreateFile(self, Obj):\r
-\r
-        if self.__IsKeyword( "CREATE_FILE"):\r
-            if not self.__IsToken( "="):\r
-                raise Warning("expected '='", self.FileName, self.CurrentLineNumber)\r
+    def _GetCreateFile(self, Obj):\r
+        if self._IsKeyword("CREATE_FILE"):\r
+            if not self._IsToken(TAB_EQUAL_SPLIT):\r
+                raise Warning.ExpectedEquals(self.FileName, self.CurrentLineNumber)\r

 \r
 \r

-            if not self.__GetNextToken():\r
-                raise Warning("expected file name", self.FileName, self.CurrentLineNumber)\r
+            if not self._GetNextToken():\r
+                raise Warning.Expected("file name", self.FileName, self.CurrentLineNumber)\r

 \r
 \r

-            FileName = self.__Token\r
+            FileName = self._Token\r

             Obj.CreateFileName = FileName\r
 \r
         return True\r
 \r
             Obj.CreateFileName = FileName\r
 \r
         return True\r
 \r

-    ## __GetTokenStatements() method\r
+    def SetPcdLocalation(self,pcdpair):\r
+        self.Profile.PcdLocalDict[pcdpair] = (self.Profile.FileName,self.CurrentLineNumber)\r
+\r
+    ## _GetTokenStatements() method\r

     #\r
     #   Get token statements\r
     #\r
     #   @param  self        The object pointer\r
     #   @param  Obj         for whom token statement is got\r
     #\r
     #\r
     #   Get token statements\r
     #\r
     #   @param  self        The object pointer\r
     #   @param  Obj         for whom token statement is got\r
     #\r

-    def __GetTokenStatements(self, Obj):\r
-        if self.__IsKeyword( "BaseAddress"):\r
-            if not self.__IsToken( "="):\r
-                raise Warning("expected '='", self.FileName, self.CurrentLineNumber)\r
-    \r
-            if not self.__GetNextHexNumber():\r
-                raise Warning("expected Hex base address", self.FileName, self.CurrentLineNumber)\r
-    \r
-            Obj.BaseAddress = self.__Token\r
-    \r
-            if self.__IsToken( "|"):\r
-                pcdPair = self.__GetNextPcdName()\r
+    def _GetTokenStatements(self, Obj):\r
+        if self._IsKeyword("BaseAddress"):\r
+            if not self._IsToken(TAB_EQUAL_SPLIT):\r
+                raise Warning.ExpectedEquals(self.FileName, self.CurrentLineNumber)\r
+\r
+            if not self._GetNextHexNumber():\r
+                raise Warning.Expected("Hex base address", self.FileName, self.CurrentLineNumber)\r
+\r
+            Obj.BaseAddress = self._Token\r
+\r
+            if self._IsToken(TAB_VALUE_SPLIT):\r
+                pcdPair = self._GetNextPcdSettings()\r

                 Obj.BaseAddressPcd = pcdPair\r
                 self.Profile.PcdDict[pcdPair] = Obj.BaseAddress\r
                 Obj.BaseAddressPcd = pcdPair\r
                 self.Profile.PcdDict[pcdPair] = Obj.BaseAddress\r

+                self.SetPcdLocalation(pcdPair)\r

                 FileLineTuple = GetRealFileLine(self.FileName, self.CurrentLineNumber)\r
                 self.Profile.PcdFileLineDict[pcdPair] = FileLineTuple\r
             return True\r
 \r
                 FileLineTuple = GetRealFileLine(self.FileName, self.CurrentLineNumber)\r
                 self.Profile.PcdFileLineDict[pcdPair] = FileLineTuple\r
             return True\r
 \r

-        if self.__IsKeyword( "Size"):\r
-            if not self.__IsToken( "="):\r
-                raise Warning("expected '='", self.FileName, self.CurrentLineNumber)\r
-    \r
-            if not self.__GetNextHexNumber():\r
-                raise Warning("expected Hex size", self.FileName, self.CurrentLineNumber)\r
+        if self._IsKeyword("Size"):\r
+            if not self._IsToken(TAB_EQUAL_SPLIT):\r
+                raise Warning.ExpectedEquals(self.FileName, self.CurrentLineNumber)\r
+\r
+            if not self._GetNextHexNumber():\r
+                raise Warning.Expected("Hex size", self.FileName, self.CurrentLineNumber)\r

 \r
 \r

-            Size = self.__Token\r
-            if self.__IsToken( "|"):\r
-                pcdPair = self.__GetNextPcdName()\r
+            Size = self._Token\r
+            if self._IsToken(TAB_VALUE_SPLIT):\r
+                pcdPair = self._GetNextPcdSettings()\r

                 Obj.SizePcd = pcdPair\r
                 self.Profile.PcdDict[pcdPair] = Size\r
                 Obj.SizePcd = pcdPair\r
                 self.Profile.PcdDict[pcdPair] = Size\r

+                self.SetPcdLocalation(pcdPair)\r

                 FileLineTuple = GetRealFileLine(self.FileName, self.CurrentLineNumber)\r
                 self.Profile.PcdFileLineDict[pcdPair] = FileLineTuple\r
                 FileLineTuple = GetRealFileLine(self.FileName, self.CurrentLineNumber)\r
                 self.Profile.PcdFileLineDict[pcdPair] = FileLineTuple\r

-            Obj.Size = long(Size, 0)\r
+            Obj.Size = int(Size, 0)\r

             return True\r
 \r
             return True\r
 \r

-        if self.__IsKeyword( "ErasePolarity"):\r
-            if not self.__IsToken( "="):\r
-                raise Warning("expected '='", self.FileName, self.CurrentLineNumber)\r
-    \r
-            if not self.__GetNextToken():\r
-                raise Warning("expected Erase Polarity", self.FileName, self.CurrentLineNumber)\r
-    \r
-            if self.__Token != "1" and self.__Token != "0":\r
-                raise Warning("expected 1 or 0 Erase Polarity", self.FileName, self.CurrentLineNumber)\r
-    \r
-            Obj.ErasePolarity = self.__Token\r
+        if self._IsKeyword("ErasePolarity"):\r
+            if not self._IsToken(TAB_EQUAL_SPLIT):\r
+                raise Warning.ExpectedEquals(self.FileName, self.CurrentLineNumber)\r
+\r
+            if not self._GetNextToken():\r
+                raise Warning.Expected("Erase Polarity", self.FileName, self.CurrentLineNumber)\r
+\r
+            if not self._Token in {"1", "0"}:\r
+                raise Warning.Expected("1 or 0 Erase Polarity", self.FileName, self.CurrentLineNumber)\r
+\r
+            Obj.ErasePolarity = self._Token\r

             return True\r
 \r
             return True\r
 \r

-        return self.__GetBlockStatements(Obj)\r
+        return self._GetBlockStatements(Obj)\r

 \r
 \r

-    ## __GetAddressStatements() method\r
+    ## _GetAddressStatements() method\r

     #\r
     #   Get address statements\r
     #\r
     #\r
     #   Get address statements\r
     #\r


@@ -1625,46 +1583,45 @@ class FdfParser:
     #   @retval True        Successfully find\r
     #   @retval False       Not able to find\r
     #\r
     #   @retval True        Successfully find\r
     #   @retval False       Not able to find\r
     #\r

-    def __GetAddressStatements(self, Obj):\r
-\r
-        if self.__IsKeyword("BsBaseAddress"):\r
-            if not self.__IsToken( "="):\r
-                raise Warning("expected '='", self.FileName, self.CurrentLineNumber)\r
+    def _GetAddressStatements(self, Obj):\r
+        if self._IsKeyword("BsBaseAddress"):\r
+            if not self._IsToken(TAB_EQUAL_SPLIT):\r
+                raise Warning.ExpectedEquals(self.FileName, self.CurrentLineNumber)\r

 \r
 \r

-            if not self.__GetNextDecimalNumber() and not self.__GetNextHexNumber():\r
-                raise Warning("expected address", self.FileName, self.CurrentLineNumber)\r
+            if not self._GetNextDecimalNumber() and not self._GetNextHexNumber():\r
+                raise Warning.Expected("address", self.FileName, self.CurrentLineNumber)\r

 \r
 \r

-            BsAddress = long(self.__Token, 0)\r
+            BsAddress = int(self._Token, 0)\r

             Obj.BsBaseAddress = BsAddress\r
 \r
             Obj.BsBaseAddress = BsAddress\r
 \r

-        if self.__IsKeyword("RtBaseAddress"):\r
-            if not self.__IsToken( "="):\r
-                raise Warning("expected '='", self.FileName, self.CurrentLineNumber)\r
+        if self._IsKeyword("RtBaseAddress"):\r
+            if not self._IsToken(TAB_EQUAL_SPLIT):\r
+                raise Warning.ExpectedEquals(self.FileName, self.CurrentLineNumber)\r

 \r
 \r

-            if not self.__GetNextDecimalNumber() and not self.__GetNextHexNumber():\r
-                raise Warning("expected address", self.FileName, self.CurrentLineNumber)\r
+            if not self._GetNextDecimalNumber() and not self._GetNextHexNumber():\r
+                raise Warning.Expected("address", self.FileName, self.CurrentLineNumber)\r

 \r
 \r

-            RtAddress = long(self.__Token, 0)\r
+            RtAddress = int(self._Token, 0)\r

             Obj.RtBaseAddress = RtAddress\r
 \r
             Obj.RtBaseAddress = RtAddress\r
 \r

-    ## __GetBlockStatements() method\r
+    ## _GetBlockStatements() method\r

     #\r
     #   Get block statements\r
     #\r
     #   @param  self        The object pointer\r
     #   @param  Obj         for whom block statement is got\r
     #\r
     #\r
     #   Get block statements\r
     #\r
     #   @param  self        The object pointer\r
     #   @param  Obj         for whom block statement is got\r
     #\r

-    def __GetBlockStatements(self, Obj):\r
+    def _GetBlockStatements(self, Obj):\r

         IsBlock = False\r
         IsBlock = False\r

-        while self.__GetBlockStatement(Obj):\r
+        while self._GetBlockStatement(Obj):\r

             IsBlock = True\r
             IsBlock = True\r

-        \r
+\r

             Item = Obj.BlockSizeList[-1]\r
             if Item[0] is None or Item[1] is None:\r
             Item = Obj.BlockSizeList[-1]\r
             if Item[0] is None or Item[1] is None:\r

-                raise Warning("expected block statement", self.FileName, self.CurrentLineNumber)\r
+                raise Warning.Expected("block statement", self.FileName, self.CurrentLineNumber)\r

         return IsBlock\r
 \r
         return IsBlock\r
 \r

-    ## __GetBlockStatement() method\r
+    ## _GetBlockStatement() method\r

     #\r
     #   Get block statement\r
     #\r
     #\r
     #   Get block statement\r
     #\r


@@ -1673,40 +1630,41 @@ class FdfParser:
     #   @retval True        Successfully find\r
     #   @retval False       Not able to find\r
     #\r
     #   @retval True        Successfully find\r
     #   @retval False       Not able to find\r
     #\r

-    def __GetBlockStatement(self, Obj):\r
-        if not self.__IsKeyword( "BlockSize"):\r
+    def _GetBlockStatement(self, Obj):\r
+        if not self._IsKeyword("BlockSize"):\r

             return False\r
 \r
             return False\r
 \r

-        if not self.__IsToken( "="):\r
-            raise Warning("expected '='", self.FileName, self.CurrentLineNumber)\r
+        if not self._IsToken(TAB_EQUAL_SPLIT):\r
+            raise Warning.ExpectedEquals(self.FileName, self.CurrentLineNumber)\r

 \r
 \r

-        if not self.__GetNextHexNumber() and not self.__GetNextDecimalNumber():\r
-            raise Warning("expected Hex or Integer block size", self.FileName, self.CurrentLineNumber)\r
+        if not self._GetNextHexNumber() and not self._GetNextDecimalNumber():\r
+            raise Warning.Expected("Hex or Integer block size", self.FileName, self.CurrentLineNumber)\r

 \r
 \r

-        BlockSize = self.__Token\r
+        BlockSize = self._Token\r

         BlockSizePcd = None\r
         BlockSizePcd = None\r

-        if self.__IsToken( "|"):\r
-            PcdPair = self.__GetNextPcdName()\r
+        if self._IsToken(TAB_VALUE_SPLIT):\r
+            PcdPair = self._GetNextPcdSettings()\r

             BlockSizePcd = PcdPair\r
             self.Profile.PcdDict[PcdPair] = BlockSize\r
             BlockSizePcd = PcdPair\r
             self.Profile.PcdDict[PcdPair] = BlockSize\r

+            self.SetPcdLocalation(PcdPair)\r

             FileLineTuple = GetRealFileLine(self.FileName, self.CurrentLineNumber)\r
             self.Profile.PcdFileLineDict[PcdPair] = FileLineTuple\r
             FileLineTuple = GetRealFileLine(self.FileName, self.CurrentLineNumber)\r
             self.Profile.PcdFileLineDict[PcdPair] = FileLineTuple\r

-        BlockSize = long(BlockSize, 0)\r
+        BlockSize = int(BlockSize, 0)\r

 \r
         BlockNumber = None\r
 \r
         BlockNumber = None\r

-        if self.__IsKeyword( "NumBlocks"):\r
-            if not self.__IsToken( "="):\r
-                raise Warning("expected '='", self.FileName, self.CurrentLineNumber)\r
+        if self._IsKeyword("NumBlocks"):\r
+            if not self._IsToken(TAB_EQUAL_SPLIT):\r
+                raise Warning.ExpectedEquals(self.FileName, self.CurrentLineNumber)\r

 \r
 \r

-            if not self.__GetNextDecimalNumber() and not self.__GetNextHexNumber():\r
-                raise Warning("expected block numbers", self.FileName, self.CurrentLineNumber)\r
+            if not self._GetNextDecimalNumber() and not self._GetNextHexNumber():\r
+                raise Warning.Expected("block numbers", self.FileName, self.CurrentLineNumber)\r

 \r
 \r

-            BlockNumber = long(self.__Token, 0)\r
+            BlockNumber = int(self._Token, 0)\r

 \r
         Obj.BlockSizeList.append((BlockSize, BlockNumber, BlockSizePcd))\r
         return True\r
 \r
 \r
         Obj.BlockSizeList.append((BlockSize, BlockNumber, BlockSizePcd))\r
         return True\r
 \r

-    ## __GetDefineStatements() method\r
+    ## _GetDefineStatements() method\r

     #\r
     #   Get define statements\r
     #\r
     #\r
     #   Get define statements\r
     #\r


@@ -1715,11 +1673,11 @@ class FdfParser:
     #   @retval True        Successfully find\r
     #   @retval False       Not able to find\r
     #\r
     #   @retval True        Successfully find\r
     #   @retval False       Not able to find\r
     #\r

-    def __GetDefineStatements(self, Obj):\r
-        while self.__GetDefineStatement( Obj):\r
+    def _GetDefineStatements(self, Obj):\r
+        while self._GetDefineStatement(Obj):\r

             pass\r
 \r
             pass\r
 \r

-    ## __GetDefineStatement() method\r
+    ## _GetDefineStatement() method\r

     #\r
     #   Get define statement\r
     #\r
     #\r
     #   Get define statement\r
     #\r


@@ -1728,24 +1686,24 @@ class FdfParser:
     #   @retval True        Successfully find\r
     #   @retval False       Not able to find\r
     #\r
     #   @retval True        Successfully find\r
     #   @retval False       Not able to find\r
     #\r

-    def __GetDefineStatement(self, Obj):\r
-        if self.__IsKeyword("DEFINE"):\r
-            self.__GetNextToken()\r
-            Macro = self.__Token\r
-            if not self.__IsToken( "="):\r
-                raise Warning("expected '='", self.FileName, self.CurrentLineNumber)\r
+    def _GetDefineStatement(self, Obj):\r
+        if self._IsKeyword(TAB_DEFINE):\r
+            self._GetNextToken()\r
+            Macro = self._Token\r
+            if not self._IsToken(TAB_EQUAL_SPLIT):\r
+                raise Warning.ExpectedEquals(self.FileName, self.CurrentLineNumber)\r

 \r
 \r

-            if not self.__GetNextToken():\r
-                raise Warning("expected value", self.FileName, self.CurrentLineNumber)\r
+            if not self._GetNextToken():\r
+                raise Warning.Expected("value", self.FileName, self.CurrentLineNumber)\r

 \r
 \r

-            Value = self.__Token\r
+            Value = self._Token\r

             Macro = '$(' + Macro + ')'\r
             Obj.DefineVarDict[Macro] = Value\r
             return True\r
 \r
         return False\r
 \r
             Macro = '$(' + Macro + ')'\r
             Obj.DefineVarDict[Macro] = Value\r
             return True\r
 \r
         return False\r
 \r

-    ## __GetSetStatements() method\r
+    ## _GetSetStatements() method\r

     #\r
     #   Get set statements\r
     #\r
     #\r
     #   Get set statements\r
     #\r


@@ -1754,11 +1712,11 @@ class FdfParser:
     #   @retval True        Successfully find\r
     #   @retval False       Not able to find\r
     #\r
     #   @retval True        Successfully find\r
     #   @retval False       Not able to find\r
     #\r

-    def __GetSetStatements(self, Obj):\r
-        while self.__GetSetStatement(Obj):\r
+    def _GetSetStatements(self, Obj):\r
+        while self._GetSetStatement(Obj):\r

             pass\r
 \r
             pass\r
 \r

-    ## __GetSetStatement() method\r
+    ## _GetSetStatement() method\r

     #\r
     #   Get set statement\r
     #\r
     #\r
     #   Get set statement\r
     #\r


@@ -1767,38 +1725,39 @@ class FdfParser:
     #   @retval True        Successfully find\r
     #   @retval False       Not able to find\r
     #\r
     #   @retval True        Successfully find\r
     #   @retval False       Not able to find\r
     #\r

-    def __GetSetStatement(self, Obj):\r
-        if self.__IsKeyword("SET"):\r
-            PcdPair = self.__GetNextPcdName()\r
+    def _GetSetStatement(self, Obj):\r
+        if self._IsKeyword("SET"):\r
+            PcdPair = self._GetNextPcdSettings()\r

 \r
 \r

-            if not self.__IsToken( "="):\r
-                raise Warning("expected '='", self.FileName, self.CurrentLineNumber)\r
+            if not self._IsToken(TAB_EQUAL_SPLIT):\r
+                raise Warning.ExpectedEquals(self.FileName, self.CurrentLineNumber)\r

 \r
 \r

-            Value = self.__GetExpression()\r
-            Value = self.__EvaluateConditional(Value, self.CurrentLineNumber, 'eval', True)\r
+            Value = self._GetExpression()\r
+            Value = self._EvaluateConditional(Value, self.CurrentLineNumber, 'eval', True)\r

 \r
             if Obj:\r
                 Obj.SetVarDict[PcdPair] = Value\r
             self.Profile.PcdDict[PcdPair] = Value\r
 \r
             if Obj:\r
                 Obj.SetVarDict[PcdPair] = Value\r
             self.Profile.PcdDict[PcdPair] = Value\r

+            self.SetPcdLocalation(PcdPair)\r

             FileLineTuple = GetRealFileLine(self.FileName, self.CurrentLineNumber)\r
             self.Profile.PcdFileLineDict[PcdPair] = FileLineTuple\r
             return True\r
 \r
         return False\r
 \r
             FileLineTuple = GetRealFileLine(self.FileName, self.CurrentLineNumber)\r
             self.Profile.PcdFileLineDict[PcdPair] = FileLineTuple\r
             return True\r
 \r
         return False\r
 \r

-    ## __CalcRegionExpr(self)\r
+    ## _CalcRegionExpr(self)\r

     #\r
     #   Calculate expression for offset or size of a region\r
     #\r
     #   @return: None if invalid expression\r
     #            Calculated number if successfully\r
     #\r
     #\r
     #   Calculate expression for offset or size of a region\r
     #\r
     #   @return: None if invalid expression\r
     #            Calculated number if successfully\r
     #\r

-    def __CalcRegionExpr(self):\r
+    def _CalcRegionExpr(self):\r

         StartPos = self.GetFileBufferPos()\r
         Expr = ''\r
         PairCount = 0\r
         StartPos = self.GetFileBufferPos()\r
         Expr = ''\r
         PairCount = 0\r

-        while not self.__EndOfFile():\r
-            CurCh = self.__CurrentChar()\r
+        while not self._EndOfFile():\r
+            CurCh = self._CurrentChar()\r

             if CurCh == '(':\r
                 PairCount += 1\r
             elif CurCh == ')':\r
             if CurCh == '(':\r
                 PairCount += 1\r
             elif CurCh == ')':\r


@@ -1807,104 +1766,106 @@ class FdfParser:
             if CurCh in '|\r\n' and PairCount == 0:\r
                 break\r
             Expr += CurCh\r
             if CurCh in '|\r\n' and PairCount == 0:\r
                 break\r
             Expr += CurCh\r

-            self.__GetOneChar()\r
+            self._GetOneChar()\r

         try:\r
         try:\r

-            return long(\r
+            return int(\r

                 ValueExpression(Expr,\r
                 ValueExpression(Expr,\r

-                                self.__CollectMacroPcd()\r
-                                )(True),0)\r
+                                self._CollectMacroPcd()\r
+                                )(True), 0)\r

         except Exception:\r
             self.SetFileBufferPos(StartPos)\r
             return None\r
 \r
         except Exception:\r
             self.SetFileBufferPos(StartPos)\r
             return None\r
 \r

-    ## __GetRegionLayout() method\r
+    ## _GetRegionLayout() method\r

     #\r
     #   Get region layout for FD\r
     #\r
     #   @param  self        The object pointer\r
     #\r
     #   Get region layout for FD\r
     #\r
     #   @param  self        The object pointer\r

-    #   @param  Fd          for whom region is got\r
+    #   @param  theFd       for whom region is got\r

     #   @retval True        Successfully find\r
     #   @retval False       Not able to find\r
     #\r
     #   @retval True        Successfully find\r
     #   @retval False       Not able to find\r
     #\r

-    def __GetRegionLayout(self, Fd):\r
-        Offset = self.__CalcRegionExpr() \r
+    def _GetRegionLayout(self, theFd):\r
+        Offset = self._CalcRegionExpr()\r

         if Offset is None:\r
             return False\r
 \r
         if Offset is None:\r
             return False\r
 \r

-        RegionObj = Region.Region()\r
+        RegionObj = Region()\r

         RegionObj.Offset = Offset\r
         RegionObj.Offset = Offset\r

-        Fd.RegionList.append(RegionObj)\r
+        theFd.RegionList.append(RegionObj)\r

 \r
 \r

-        if not self.__IsToken( "|"):\r
-            raise Warning("expected '|'", self.FileName, self.CurrentLineNumber)\r
+        if not self._IsToken(TAB_VALUE_SPLIT):\r
+            raise Warning.Expected("'|'", self.FileName, self.CurrentLineNumber)\r

 \r
 \r

-        Size = self.__CalcRegionExpr()\r
+        Size = self._CalcRegionExpr()\r

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

-            raise Warning("expected Region Size", self.FileName, self.CurrentLineNumber)\r
+            raise Warning.Expected("Region Size", self.FileName, self.CurrentLineNumber)\r

         RegionObj.Size = Size\r
 \r
         RegionObj.Size = Size\r
 \r

-        if not self.__GetNextWord():\r
+        if not self._GetNextWord():\r

             return True\r
 \r
             return True\r
 \r

-        if not self.__Token in ("SET", "FV", "FILE", "DATA", "CAPSULE", "INF"):\r
+        if not self._Token in {"SET", BINARY_FILE_TYPE_FV, "FILE", "DATA", "CAPSULE", "INF"}:\r

             #\r
             # If next token is a word which is not a valid FV type, it might be part of [PcdOffset[|PcdSize]]\r
             # Or it might be next region's offset described by an expression which starts with a PCD.\r
             #    PcdOffset[|PcdSize] or OffsetPcdExpression|Size\r
             #\r
             #\r
             # If next token is a word which is not a valid FV type, it might be part of [PcdOffset[|PcdSize]]\r
             # Or it might be next region's offset described by an expression which starts with a PCD.\r
             #    PcdOffset[|PcdSize] or OffsetPcdExpression|Size\r
             #\r

-            self.__UndoToken()\r
-            IsRegionPcd = (RegionSizeGuidPattern.match(self.__CurrentLine()[self.CurrentOffsetWithinLine:]) or\r
-                           RegionOffsetPcdPattern.match(self.__CurrentLine()[self.CurrentOffsetWithinLine:]))\r
+            self._UndoToken()\r
+            IsRegionPcd = (RegionSizeGuidPattern.match(self._CurrentLine()[self.CurrentOffsetWithinLine:]) or\r
+                           RegionOffsetPcdPattern.match(self._CurrentLine()[self.CurrentOffsetWithinLine:]))\r

             if IsRegionPcd:\r
             if IsRegionPcd:\r

-                RegionObj.PcdOffset = self.__GetNextPcdName()\r
-                self.Profile.PcdDict[RegionObj.PcdOffset] = "0x%08X" % (RegionObj.Offset + long(Fd.BaseAddress, 0))\r
-                self.__PcdDict['%s.%s' % (RegionObj.PcdOffset[1], RegionObj.PcdOffset[0])] = "0x%x" % RegionObj.Offset\r
+                RegionObj.PcdOffset = self._GetNextPcdSettings()\r
+                self.Profile.PcdDict[RegionObj.PcdOffset] = "0x%08X" % (RegionObj.Offset + int(theFd.BaseAddress, 0))\r
+                self.SetPcdLocalation(RegionObj.PcdOffset)\r
+                self._PcdDict['%s.%s' % (RegionObj.PcdOffset[1], RegionObj.PcdOffset[0])] = "0x%x" % RegionObj.Offset\r

                 FileLineTuple = GetRealFileLine(self.FileName, self.CurrentLineNumber)\r
                 self.Profile.PcdFileLineDict[RegionObj.PcdOffset] = FileLineTuple\r
                 FileLineTuple = GetRealFileLine(self.FileName, self.CurrentLineNumber)\r
                 self.Profile.PcdFileLineDict[RegionObj.PcdOffset] = FileLineTuple\r

-                if self.__IsToken( "|"):\r
-                    RegionObj.PcdSize = self.__GetNextPcdName()\r
+                if self._IsToken(TAB_VALUE_SPLIT):\r
+                    RegionObj.PcdSize = self._GetNextPcdSettings()\r

                     self.Profile.PcdDict[RegionObj.PcdSize] = "0x%08X" % RegionObj.Size\r
                     self.Profile.PcdDict[RegionObj.PcdSize] = "0x%08X" % RegionObj.Size\r

-                    self.__PcdDict['%s.%s' % (RegionObj.PcdSize[1], RegionObj.PcdSize[0])] = "0x%x" % RegionObj.Size\r
+                    self.SetPcdLocalation(RegionObj.PcdSize)\r
+                    self._PcdDict['%s.%s' % (RegionObj.PcdSize[1], RegionObj.PcdSize[0])] = "0x%x" % RegionObj.Size\r

                     FileLineTuple = GetRealFileLine(self.FileName, self.CurrentLineNumber)\r
                     self.Profile.PcdFileLineDict[RegionObj.PcdSize] = FileLineTuple\r
 \r
                     FileLineTuple = GetRealFileLine(self.FileName, self.CurrentLineNumber)\r
                     self.Profile.PcdFileLineDict[RegionObj.PcdSize] = FileLineTuple\r
 \r

-            if not self.__GetNextWord():\r
+            if not self._GetNextWord():\r

                 return True\r
 \r
                 return True\r
 \r

-        if self.__Token == "SET":\r
-            self.__UndoToken()\r
-            self.__GetSetStatements( RegionObj)\r
-            if not self.__GetNextWord():\r
+        if self._Token == "SET":\r
+            self._UndoToken()\r
+            self._GetSetStatements(RegionObj)\r
+            if not self._GetNextWord():\r

                 return True\r
 \r
                 return True\r
 \r

-        elif self.__Token == "FV":\r
-            self.__UndoToken()\r
-            self.__GetRegionFvType( RegionObj)\r
+        elif self._Token == BINARY_FILE_TYPE_FV:\r
+            self._UndoToken()\r
+            self._GetRegionFvType(RegionObj)\r

 \r
 \r

-        elif self.__Token == "CAPSULE":\r
-            self.__UndoToken()\r
-            self.__GetRegionCapType( RegionObj)\r
+        elif self._Token == "CAPSULE":\r
+            self._UndoToken()\r
+            self._GetRegionCapType(RegionObj)\r

 \r
 \r

-        elif self.__Token == "FILE":\r
-            self.__UndoToken()\r
-            self.__GetRegionFileType(RegionObj)\r
+        elif self._Token == "FILE":\r
+            self._UndoToken()\r
+            self._GetRegionFileType(RegionObj)\r

 \r
 \r

-        elif self.__Token == "INF":\r
-            self.__UndoToken()\r
+        elif self._Token == "INF":\r
+            self._UndoToken()\r

             RegionObj.RegionType = "INF"\r
             RegionObj.RegionType = "INF"\r

-            while self.__IsKeyword("INF"):\r
-                self.__UndoToken()\r
-                ffsInf = self.__ParseInfStatement()\r
+            while self._IsKeyword("INF"):\r
+                self._UndoToken()\r
+                ffsInf = self._ParseInfStatement()\r

                 if not ffsInf:\r
                     break\r
                 RegionObj.RegionDataList.append(ffsInf)\r
 \r
                 if not ffsInf:\r
                     break\r
                 RegionObj.RegionDataList.append(ffsInf)\r
 \r

-        elif self.__Token == "DATA":\r
-            self.__UndoToken()\r
-            self.__GetRegionDataType(RegionObj)\r
+        elif self._Token == "DATA":\r
+            self._UndoToken()\r
+            self._GetRegionDataType(RegionObj)\r

         else:\r
         else:\r

-            self.__UndoToken()\r
-            if self.__GetRegionLayout(Fd):\r
+            self._UndoToken()\r
+            if self._GetRegionLayout(theFd):\r

                 return True\r
             raise Warning("A valid region type was not found. "\r
                           "Valid types are [SET, FV, CAPSULE, FILE, DATA, INF]. This error occurred",\r
                 return True\r
             raise Warning("A valid region type was not found. "\r
                           "Valid types are [SET, FV, CAPSULE, FILE, DATA, INF]. This error occurred",\r


@@ -1912,189 +1873,185 @@ class FdfParser:
 \r
         return True\r
 \r
 \r
         return True\r
 \r

-    ## __GetRegionFvType() method\r
+    ## _GetRegionFvType() method\r

     #\r
     #   Get region fv data for region\r
     #\r
     #   @param  self        The object pointer\r
     #   @param  RegionObj   for whom region data is got\r
     #\r
     #\r
     #   Get region fv data for region\r
     #\r
     #   @param  self        The object pointer\r
     #   @param  RegionObj   for whom region data is got\r
     #\r

-    def __GetRegionFvType(self, RegionObj):\r
-\r
-        if not self.__IsKeyword( "FV"):\r
-            raise Warning("expected Keyword 'FV'", self.FileName, self.CurrentLineNumber)\r
+    def _GetRegionFvType(self, RegionObj):\r
+        if not self._IsKeyword(BINARY_FILE_TYPE_FV):\r
+            raise Warning.Expected("'FV'", self.FileName, self.CurrentLineNumber)\r

 \r
 \r

-        if not self.__IsToken( "="):\r
-            raise Warning("expected '='", self.FileName, self.CurrentLineNumber)\r
+        if not self._IsToken(TAB_EQUAL_SPLIT):\r
+            raise Warning.ExpectedEquals(self.FileName, self.CurrentLineNumber)\r

 \r
 \r

-        if not self.__GetNextToken():\r
-            raise Warning("expected FV name", self.FileName, self.CurrentLineNumber)\r
+        if not self._GetNextToken():\r
+            raise Warning.Expected("FV name", self.FileName, self.CurrentLineNumber)\r

 \r
 \r

-        RegionObj.RegionType = "FV"\r
-        RegionObj.RegionDataList.append((self.__Token).upper())\r
+        RegionObj.RegionType = BINARY_FILE_TYPE_FV\r
+        RegionObj.RegionDataList.append((self._Token).upper())\r

 \r
 \r

-        while self.__IsKeyword( "FV"):\r
+        while self._IsKeyword(BINARY_FILE_TYPE_FV):\r

 \r
 \r

-            if not self.__IsToken( "="):\r
-                raise Warning("expected '='", self.FileName, self.CurrentLineNumber)\r
+            if not self._IsToken(TAB_EQUAL_SPLIT):\r
+                raise Warning.ExpectedEquals(self.FileName, self.CurrentLineNumber)\r

 \r
 \r

-            if not self.__GetNextToken():\r
-                raise Warning("expected FV name", self.FileName, self.CurrentLineNumber)\r
+            if not self._GetNextToken():\r
+                raise Warning.Expected("FV name", self.FileName, self.CurrentLineNumber)\r

 \r
 \r

-            RegionObj.RegionDataList.append((self.__Token).upper())\r
+            RegionObj.RegionDataList.append((self._Token).upper())\r

 \r
 \r

-    ## __GetRegionCapType() method\r
+    ## _GetRegionCapType() method\r

     #\r
     #   Get region capsule data for region\r
     #\r
     #   @param  self        The object pointer\r
     #   @param  RegionObj   for whom region data is got\r
     #\r
     #\r
     #   Get region capsule data for region\r
     #\r
     #   @param  self        The object pointer\r
     #   @param  RegionObj   for whom region data is got\r
     #\r

-    def __GetRegionCapType(self, RegionObj):\r
+    def _GetRegionCapType(self, RegionObj):\r
+        if not self._IsKeyword("CAPSULE"):\r
+            raise Warning.Expected("'CAPSULE'", self.FileName, self.CurrentLineNumber)\r

 \r
 \r

-        if not self.__IsKeyword("CAPSULE"):\r
-            raise Warning("expected Keyword 'CAPSULE'", self.FileName, self.CurrentLineNumber)\r
+        if not self._IsToken(TAB_EQUAL_SPLIT):\r
+            raise Warning.ExpectedEquals(self.FileName, self.CurrentLineNumber)\r

 \r
 \r

-        if not self.__IsToken("="):\r
-            raise Warning("expected '='", self.FileName, self.CurrentLineNumber)\r
-\r
-        if not self.__GetNextToken():\r
-            raise Warning("expected CAPSULE name", self.FileName, self.CurrentLineNumber)\r
+        if not self._GetNextToken():\r
+            raise Warning.Expected("CAPSULE name", self.FileName, self.CurrentLineNumber)\r

 \r
         RegionObj.RegionType = "CAPSULE"\r
 \r
         RegionObj.RegionType = "CAPSULE"\r

-        RegionObj.RegionDataList.append(self.__Token)\r
+        RegionObj.RegionDataList.append(self._Token)\r

 \r
 \r

-        while self.__IsKeyword("CAPSULE"):\r
+        while self._IsKeyword("CAPSULE"):\r

 \r
 \r

-            if not self.__IsToken("="):\r
-                raise Warning("expected '='", self.FileName, self.CurrentLineNumber)\r
+            if not self._IsToken(TAB_EQUAL_SPLIT):\r
+                raise Warning.ExpectedEquals(self.FileName, self.CurrentLineNumber)\r

 \r
 \r

-            if not self.__GetNextToken():\r
-                raise Warning("expected CAPSULE name", self.FileName, self.CurrentLineNumber)\r
+            if not self._GetNextToken():\r
+                raise Warning.Expected("CAPSULE name", self.FileName, self.CurrentLineNumber)\r

 \r
 \r

-            RegionObj.RegionDataList.append(self.__Token)\r
+            RegionObj.RegionDataList.append(self._Token)\r

 \r
 \r

-    ## __GetRegionFileType() method\r
+    ## _GetRegionFileType() method\r

     #\r
     #   Get region file data for region\r
     #\r
     #   @param  self        The object pointer\r
     #   @param  RegionObj   for whom region data is got\r
     #\r
     #\r
     #   Get region file data for region\r
     #\r
     #   @param  self        The object pointer\r
     #   @param  RegionObj   for whom region data is got\r
     #\r

-    def __GetRegionFileType(self, RegionObj):\r
-\r
-        if not self.__IsKeyword( "FILE"):\r
-            raise Warning("expected Keyword 'FILE'", self.FileName, self.CurrentLineNumber)\r
+    def _GetRegionFileType(self, RegionObj):\r
+        if not self._IsKeyword("FILE"):\r
+            raise Warning.Expected("'FILE'", self.FileName, self.CurrentLineNumber)\r

 \r
 \r

-        if not self.__IsToken( "="):\r
-            raise Warning("expected '='", self.FileName, self.CurrentLineNumber)\r
+        if not self._IsToken(TAB_EQUAL_SPLIT):\r
+            raise Warning.ExpectedEquals(self.FileName, self.CurrentLineNumber)\r

 \r
 \r

-        if not self.__GetNextToken():\r
-            raise Warning("expected File name", self.FileName, self.CurrentLineNumber)\r
+        if not self._GetNextToken():\r
+            raise Warning.Expected("File name", self.FileName, self.CurrentLineNumber)\r

 \r
         RegionObj.RegionType = "FILE"\r
 \r
         RegionObj.RegionType = "FILE"\r

-        RegionObj.RegionDataList.append( self.__Token)\r
+        RegionObj.RegionDataList.append(self._Token)\r

 \r
 \r

-        while self.__IsKeyword( "FILE"):\r
+        while self._IsKeyword("FILE"):\r

 \r
 \r

-            if not self.__IsToken( "="):\r
-                raise Warning("expected '='", self.FileName, self.CurrentLineNumber)\r
+            if not self._IsToken(TAB_EQUAL_SPLIT):\r
+                raise Warning.ExpectedEquals(self.FileName, self.CurrentLineNumber)\r

 \r
 \r

-            if not self.__GetNextToken():\r
-                raise Warning("expected FILE name", self.FileName, self.CurrentLineNumber)\r
+            if not self._GetNextToken():\r
+                raise Warning.Expected("FILE name", self.FileName, self.CurrentLineNumber)\r

 \r
 \r

-            RegionObj.RegionDataList.append(self.__Token)\r
+            RegionObj.RegionDataList.append(self._Token)\r

 \r
 \r

-    ## __GetRegionDataType() method\r
+    ## _GetRegionDataType() method\r

     #\r
     #   Get region array data for region\r
     #\r
     #   @param  self        The object pointer\r
     #   @param  RegionObj   for whom region data is got\r
     #\r
     #\r
     #   Get region array data for region\r
     #\r
     #   @param  self        The object pointer\r
     #   @param  RegionObj   for whom region data is got\r
     #\r

-    def __GetRegionDataType(self, RegionObj):\r
-\r
-        if not self.__IsKeyword( "DATA"):\r
-            raise Warning("expected Region Data type", self.FileName, self.CurrentLineNumber)\r
+    def _GetRegionDataType(self, RegionObj):\r
+        if not self._IsKeyword("DATA"):\r
+            raise Warning.Expected("Region Data type", self.FileName, self.CurrentLineNumber)\r

 \r
 \r

-        if not self.__IsToken( "="):\r
-            raise Warning("expected '='", self.FileName, self.CurrentLineNumber)\r
+        if not self._IsToken(TAB_EQUAL_SPLIT):\r
+            raise Warning.ExpectedEquals(self.FileName, self.CurrentLineNumber)\r

 \r
 \r

-        if not self.__IsToken( "{"):\r
-            raise Warning("expected '{'", self.FileName, self.CurrentLineNumber)\r
+        if not self._IsToken("{"):\r
+            raise Warning.ExpectedCurlyOpen(self.FileName, self.CurrentLineNumber)\r

 \r
 \r

-        if not self.__GetNextHexNumber():\r
-            raise Warning("expected Hex byte", self.FileName, self.CurrentLineNumber)\r
+        if not self._GetNextHexNumber():\r
+            raise Warning.Expected("Hex byte", self.FileName, self.CurrentLineNumber)\r

 \r
 \r

-        if len(self.__Token) > 18:\r
+        if len(self._Token) > 18:\r

             raise Warning("Hex string can't be converted to a valid UINT64 value", self.FileName, self.CurrentLineNumber)\r
 \r
         # convert hex string value to byte hex string array\r
             raise Warning("Hex string can't be converted to a valid UINT64 value", self.FileName, self.CurrentLineNumber)\r
 \r
         # convert hex string value to byte hex string array\r

-        AllString = self.__Token\r
+        AllString = self._Token\r

         AllStrLen = len (AllString)\r
         DataString = ""\r
         while AllStrLen > 4:\r
         AllStrLen = len (AllString)\r
         DataString = ""\r
         while AllStrLen > 4:\r

-            DataString = DataString + "0x" + AllString[AllStrLen - 2: AllStrLen] + ","\r
+            DataString = DataString + "0x" + AllString[AllStrLen - 2: AllStrLen] + TAB_COMMA_SPLIT\r

             AllStrLen  = AllStrLen - 2\r
             AllStrLen  = AllStrLen - 2\r

-        DataString = DataString + AllString[:AllStrLen] + ","\r
+        DataString = DataString + AllString[:AllStrLen] + TAB_COMMA_SPLIT\r

 \r
         # byte value array\r
 \r
         # byte value array\r

-        if len (self.__Token) <= 4:\r
-            while self.__IsToken(","):\r
-                if not self.__GetNextHexNumber():\r
+        if len (self._Token) <= 4:\r
+            while self._IsToken(TAB_COMMA_SPLIT):\r
+                if not self._GetNextHexNumber():\r

                     raise Warning("Invalid Hex number", self.FileName, self.CurrentLineNumber)\r
                     raise Warning("Invalid Hex number", self.FileName, self.CurrentLineNumber)\r

-                if len(self.__Token) > 4:\r
+                if len(self._Token) > 4:\r

                     raise Warning("Hex byte(must be 2 digits) too long", self.FileName, self.CurrentLineNumber)\r
                     raise Warning("Hex byte(must be 2 digits) too long", self.FileName, self.CurrentLineNumber)\r

-                DataString += self.__Token\r
-                DataString += ","\r
+                DataString += self._Token\r
+                DataString += TAB_COMMA_SPLIT\r

 \r
 \r

-        if not self.__IsToken( "}"):\r
-            raise Warning("expected '}'", self.FileName, self.CurrentLineNumber)\r
+        if not self._IsToken(T_CHAR_BRACE_R):\r
+            raise Warning.ExpectedCurlyClose(self.FileName, self.CurrentLineNumber)\r

 \r
 \r

-        DataString = DataString.rstrip(",")\r
+        DataString = DataString.rstrip(TAB_COMMA_SPLIT)\r

         RegionObj.RegionType = "DATA"\r
         RegionObj.RegionType = "DATA"\r

-        RegionObj.RegionDataList.append( DataString)\r
+        RegionObj.RegionDataList.append(DataString)\r

 \r
 \r

-        while self.__IsKeyword( "DATA"):\r
+        while self._IsKeyword("DATA"):\r

 \r
 \r

-            if not self.__IsToken( "="):\r
-                raise Warning("expected '='", self.FileName, self.CurrentLineNumber)\r
+            if not self._IsToken(TAB_EQUAL_SPLIT):\r
+                raise Warning.ExpectedEquals(self.FileName, self.CurrentLineNumber)\r

 \r
 \r

-            if not self.__IsToken( "{"):\r
-                raise Warning("expected '{'", self.FileName, self.CurrentLineNumber)\r
+            if not self._IsToken("{"):\r
+                raise Warning.ExpectedCurlyOpen(self.FileName, self.CurrentLineNumber)\r

 \r
 \r

-            if not self.__GetNextHexNumber():\r
-                raise Warning("expected Hex byte", self.FileName, self.CurrentLineNumber)\r
+            if not self._GetNextHexNumber():\r
+                raise Warning.Expected("Hex byte", self.FileName, self.CurrentLineNumber)\r

 \r
 \r

-            if len(self.__Token) > 18:\r
+            if len(self._Token) > 18:\r

                 raise Warning("Hex string can't be converted to a valid UINT64 value", self.FileName, self.CurrentLineNumber)\r
 \r
             # convert hex string value to byte hex string array\r
                 raise Warning("Hex string can't be converted to a valid UINT64 value", self.FileName, self.CurrentLineNumber)\r
 \r
             # convert hex string value to byte hex string array\r

-            AllString = self.__Token\r
+            AllString = self._Token\r

             AllStrLen = len (AllString)\r
             DataString = ""\r
             while AllStrLen > 4:\r
             AllStrLen = len (AllString)\r
             DataString = ""\r
             while AllStrLen > 4:\r

-                DataString = DataString + "0x" + AllString[AllStrLen - 2: AllStrLen] + ","\r
+                DataString = DataString + "0x" + AllString[AllStrLen - 2: AllStrLen] + TAB_COMMA_SPLIT\r

                 AllStrLen  = AllStrLen - 2\r
                 AllStrLen  = AllStrLen - 2\r

-            DataString = DataString + AllString[:AllStrLen] + ","\r
+            DataString = DataString + AllString[:AllStrLen] + TAB_COMMA_SPLIT\r

 \r
             # byte value array\r
 \r
             # byte value array\r

-            if len (self.__Token) <= 4:\r
-                while self.__IsToken(","):\r
-                    if not self.__GetNextHexNumber():\r
+            if len (self._Token) <= 4:\r
+                while self._IsToken(TAB_COMMA_SPLIT):\r
+                    if not self._GetNextHexNumber():\r

                         raise Warning("Invalid Hex number", self.FileName, self.CurrentLineNumber)\r
                         raise Warning("Invalid Hex number", self.FileName, self.CurrentLineNumber)\r

-                    if len(self.__Token) > 4:\r
+                    if len(self._Token) > 4:\r

                         raise Warning("Hex byte(must be 2 digits) too long", self.FileName, self.CurrentLineNumber)\r
                         raise Warning("Hex byte(must be 2 digits) too long", self.FileName, self.CurrentLineNumber)\r

-                    DataString += self.__Token\r
-                    DataString += ","\r
+                    DataString += self._Token\r
+                    DataString += TAB_COMMA_SPLIT\r

 \r
 \r

-            if not self.__IsToken( "}"):\r
-                raise Warning("expected '}'", self.FileName, self.CurrentLineNumber)\r
+            if not self._IsToken(T_CHAR_BRACE_R):\r
+                raise Warning.ExpectedCurlyClose(self.FileName, self.CurrentLineNumber)\r

 \r
 \r

-            DataString = DataString.rstrip(",")\r
-            RegionObj.RegionDataList.append( DataString)\r
+            DataString = DataString.rstrip(TAB_COMMA_SPLIT)\r
+            RegionObj.RegionDataList.append(DataString)\r

 \r
 \r

-    ## __GetFv() method\r
+    ## _GetFv() method\r

     #\r
     #   Get FV section contents and store its data into FV dictionary of self.Profile\r
     #\r
     #\r
     #   Get FV section contents and store its data into FV dictionary of self.Profile\r
     #\r


@@ -2102,68 +2059,64 @@ class FdfParser:
     #   @retval True        Successfully find a FV\r
     #   @retval False       Not able to find a FV\r
     #\r
     #   @retval True        Successfully find a FV\r
     #   @retval False       Not able to find a FV\r
     #\r

-    def __GetFv(self):\r
-        if not self.__GetNextToken():\r
+    def _GetFv(self):\r
+        if not self._GetNextToken():\r

             return False\r
 \r
             return False\r
 \r

-        S = self.__Token.upper()\r
-        if S.startswith("[") and not S.startswith("[FV."):\r
+        S = self._Token.upper()\r
+        if S.startswith(TAB_SECTION_START) and not S.startswith("[FV."):\r

             self.SectionParser(S)\r
             self.SectionParser(S)\r

-            self.__UndoToken()\r
+            self._UndoToken()\r

             return False\r
 \r
             return False\r
 \r

-        self.__UndoToken()\r
-        if not self.__IsToken("[FV.", True):\r
+        self._UndoToken()\r
+        if not self._IsToken("[FV.", True):\r

             FileLineTuple = GetRealFileLine(self.FileName, self.CurrentLineNumber)\r
             #print 'Parsing String: %s in File %s, At line: %d, Offset Within Line: %d' \\r
             FileLineTuple = GetRealFileLine(self.FileName, self.CurrentLineNumber)\r
             #print 'Parsing String: %s in File %s, At line: %d, Offset Within Line: %d' \\r

-            #        % (self.Profile.FileLinesList[self.CurrentLineNumber - 1][self.CurrentOffsetWithinLine :], FileLineTuple[0], FileLineTuple[1], self.CurrentOffsetWithinLine)\r
-            raise Warning("Unknown Keyword '%s'" % self.__Token, self.FileName, self.CurrentLineNumber)\r
+            #        % (self.Profile.FileLinesList[self.CurrentLineNumber - 1][self.CurrentOffsetWithinLine:], FileLineTuple[0], FileLineTuple[1], self.CurrentOffsetWithinLine)\r
+            raise Warning("Unknown Keyword '%s'" % self._Token, self.FileName, self.CurrentLineNumber)\r

 \r
 \r

-        FvName = self.__GetUiName()\r
+        FvName = self._GetUiName()\r

         self.CurrentFvName = FvName.upper()\r
 \r
         self.CurrentFvName = FvName.upper()\r
 \r

-        if not self.__IsToken( "]"):\r
-            raise Warning("expected ']'", self.FileName, self.CurrentLineNumber)\r
+        if not self._IsToken(TAB_SECTION_END):\r
+            raise Warning.ExpectedBracketClose(self.FileName, self.CurrentLineNumber)\r

 \r
 \r

-        FvObj = Fv.FV()\r
-        FvObj.UiFvName = self.CurrentFvName\r
+        FvObj = FV(Name=self.CurrentFvName)\r

         self.Profile.FvDict[self.CurrentFvName] = FvObj\r
 \r
         self.Profile.FvDict[self.CurrentFvName] = FvObj\r
 \r

-        Status = self.__GetCreateFile(FvObj)\r
+        Status = self._GetCreateFile(FvObj)\r

         if not Status:\r
             raise Warning("FV name error", self.FileName, self.CurrentLineNumber)\r
 \r
         if not Status:\r
             raise Warning("FV name error", self.FileName, self.CurrentLineNumber)\r
 \r

-        self.__GetDefineStatements(FvObj)\r
+        self._GetDefineStatements(FvObj)\r

 \r
 \r

-        self.__GetAddressStatements(FvObj)\r
+        self._GetAddressStatements(FvObj)\r

 \r
 \r

-        FvObj.FvExtEntryTypeValue = []\r
-        FvObj.FvExtEntryType = []\r
-        FvObj.FvExtEntryData = []\r

         while True:\r
         while True:\r

-            self.__GetSetStatements(FvObj)\r
+            self._GetSetStatements(FvObj)\r

 \r
 \r

-            if not (self.__GetBlockStatement(FvObj) or self.__GetFvBaseAddress(FvObj) or \r
-                self.__GetFvForceRebase(FvObj) or self.__GetFvAlignment(FvObj) or \r
-                self.__GetFvAttributes(FvObj) or self.__GetFvNameGuid(FvObj) or \r
-                self.__GetFvExtEntryStatement(FvObj) or self.__GetFvNameString(FvObj)):\r
+            if not (self._GetBlockStatement(FvObj) or self._GetFvBaseAddress(FvObj) or\r
+                self._GetFvForceRebase(FvObj) or self._GetFvAlignment(FvObj) or\r
+                self._GetFvAttributes(FvObj) or self._GetFvNameGuid(FvObj) or\r
+                self._GetFvExtEntryStatement(FvObj) or self._GetFvNameString(FvObj)):\r

                 break\r
 \r
         if FvObj.FvNameString == 'TRUE' and not FvObj.FvNameGuid:\r
             raise Warning("FvNameString found but FvNameGuid was not found", self.FileName, self.CurrentLineNumber)\r
 \r
                 break\r
 \r
         if FvObj.FvNameString == 'TRUE' and not FvObj.FvNameGuid:\r
             raise Warning("FvNameString found but FvNameGuid was not found", self.FileName, self.CurrentLineNumber)\r
 \r

-        self.__GetAprioriSection(FvObj, FvObj.DefineVarDict.copy())\r
-        self.__GetAprioriSection(FvObj, FvObj.DefineVarDict.copy())\r
+        self._GetAprioriSection(FvObj)\r
+        self._GetAprioriSection(FvObj)\r

 \r
         while True:\r
 \r
         while True:\r

-            isInf = self.__GetInfStatement(FvObj, MacroDict = FvObj.DefineVarDict.copy())\r
-            isFile = self.__GetFileStatement(FvObj, MacroDict = FvObj.DefineVarDict.copy())\r
+            isInf = self._GetInfStatement(FvObj)\r
+            isFile = self._GetFileStatement(FvObj)\r

             if not isInf and not isFile:\r
                 break\r
 \r
         return True\r
 \r
             if not isInf and not isFile:\r
                 break\r
 \r
         return True\r
 \r

-    ## __GetFvAlignment() method\r
+    ## _GetFvAlignment() method\r

     #\r
     #   Get alignment for FV\r
     #\r
     #\r
     #   Get alignment for FV\r
     #\r


@@ -2172,26 +2125,25 @@ class FdfParser:
     #   @retval True        Successfully find a alignment statement\r
     #   @retval False       Not able to find a alignment statement\r
     #\r
     #   @retval True        Successfully find a alignment statement\r
     #   @retval False       Not able to find a alignment statement\r
     #\r

-    def __GetFvAlignment(self, Obj):\r
-\r
-        if not self.__IsKeyword( "FvAlignment"):\r
+    def _GetFvAlignment(self, Obj):\r
+        if not self._IsKeyword("FvAlignment"):\r

             return False\r
 \r
             return False\r
 \r

-        if not self.__IsToken( "="):\r
-            raise Warning("expected '='", self.FileName, self.CurrentLineNumber)\r
+        if not self._IsToken(TAB_EQUAL_SPLIT):\r
+            raise Warning.ExpectedEquals(self.FileName, self.CurrentLineNumber)\r

 \r
 \r

-        if not self.__GetNextToken():\r
-            raise Warning("expected alignment value", self.FileName, self.CurrentLineNumber)\r
+        if not self._GetNextToken():\r
+            raise Warning.Expected("alignment value", self.FileName, self.CurrentLineNumber)\r

 \r
 \r

-        if self.__Token.upper() not in ("1", "2", "4", "8", "16", "32", "64", "128", "256", "512", \\r
+        if self._Token.upper() not in {"1", "2", "4", "8", "16", "32", "64", "128", "256", "512", \\r

                                         "1K", "2K", "4K", "8K", "16K", "32K", "64K", "128K", "256K", "512K", \\r
                                         "1M", "2M", "4M", "8M", "16M", "32M", "64M", "128M", "256M", "512M", \\r
                                         "1K", "2K", "4K", "8K", "16K", "32K", "64K", "128K", "256K", "512K", \\r
                                         "1M", "2M", "4M", "8M", "16M", "32M", "64M", "128M", "256M", "512M", \\r

-                                        "1G", "2G"):\r
-            raise Warning("Unknown alignment value '%s'" % self.__Token, self.FileName, self.CurrentLineNumber)\r
-        Obj.FvAlignment = self.__Token\r
+                                        "1G", "2G"}:\r
+            raise Warning("Unknown alignment value '%s'" % self._Token, self.FileName, self.CurrentLineNumber)\r
+        Obj.FvAlignment = self._Token\r

         return True\r
         return True\r

-    \r
-    ## __GetFvBaseAddress() method\r
+\r
+    ## _GetFvBaseAddress() method\r

     #\r
     #   Get BaseAddress for FV\r
     #\r
     #\r
     #   Get BaseAddress for FV\r
     #\r


@@ -2200,25 +2152,22 @@ class FdfParser:
     #   @retval True        Successfully find a FvBaseAddress statement\r
     #   @retval False       Not able to find a FvBaseAddress statement\r
     #\r
     #   @retval True        Successfully find a FvBaseAddress statement\r
     #   @retval False       Not able to find a FvBaseAddress statement\r
     #\r

-    def __GetFvBaseAddress(self, Obj):\r
-\r
-        if not self.__IsKeyword("FvBaseAddress"):\r
+    def _GetFvBaseAddress(self, Obj):\r
+        if not self._IsKeyword("FvBaseAddress"):\r

             return False\r
 \r
             return False\r
 \r

-        if not self.__IsToken( "="):\r
-            raise Warning("expected '='", self.FileName, self.CurrentLineNumber)\r
+        if not self._IsToken(TAB_EQUAL_SPLIT):\r
+            raise Warning.ExpectedEquals(self.FileName, self.CurrentLineNumber)\r

 \r
 \r

-        if not self.__GetNextToken():\r
-            raise Warning("expected FV base address value", self.FileName, self.CurrentLineNumber)\r
+        if not self._GetNextToken():\r
+            raise Warning.Expected("FV base address value", self.FileName, self.CurrentLineNumber)\r

 \r
 \r

-        IsValidBaseAddrValue = re.compile('^0[x|X][0-9a-fA-F]+')\r
+        if not BaseAddrValuePattern.match(self._Token.upper()):\r
+            raise Warning("Unknown FV base address value '%s'" % self._Token, self.FileName, self.CurrentLineNumber)\r
+        Obj.FvBaseAddress = self._Token\r
+        return True\r

 \r
 \r

-        if not IsValidBaseAddrValue.match(self.__Token.upper()):\r
-            raise Warning("Unknown FV base address value '%s'" % self.__Token, self.FileName, self.CurrentLineNumber)\r
-        Obj.FvBaseAddress = self.__Token\r
-        return True  \r
-      \r
-    ## __GetFvForceRebase() method\r
+    ## _GetFvForceRebase() method\r

     #\r
     #   Get FvForceRebase for FV\r
     #\r
     #\r
     #   Get FvForceRebase for FV\r
     #\r


@@ -2227,31 +2176,30 @@ class FdfParser:
     #   @retval True        Successfully find a FvForceRebase statement\r
     #   @retval False       Not able to find a FvForceRebase statement\r
     #\r
     #   @retval True        Successfully find a FvForceRebase statement\r
     #   @retval False       Not able to find a FvForceRebase statement\r
     #\r

-    def __GetFvForceRebase(self, Obj):\r
-\r
-        if not self.__IsKeyword("FvForceRebase"):\r
+    def _GetFvForceRebase(self, Obj):\r
+        if not self._IsKeyword("FvForceRebase"):\r

             return False\r
 \r
             return False\r
 \r

-        if not self.__IsToken( "="):\r
-            raise Warning("expected '='", self.FileName, self.CurrentLineNumber)\r
+        if not self._IsToken(TAB_EQUAL_SPLIT):\r
+            raise Warning.ExpectedEquals(self.FileName, self.CurrentLineNumber)\r
+\r
+        if not self._GetNextToken():\r
+            raise Warning.Expected("FvForceRebase value", self.FileName, self.CurrentLineNumber)\r

 \r
 \r

-        if not self.__GetNextToken():\r
-            raise Warning("expected FvForceRebase value", self.FileName, self.CurrentLineNumber)\r
+        if self._Token.upper() not in {"TRUE", "FALSE", "0", "0X0", "0X00", "1", "0X1", "0X01"}:\r
+            raise Warning("Unknown FvForceRebase value '%s'" % self._Token, self.FileName, self.CurrentLineNumber)\r

 \r
 \r

-        if self.__Token.upper() not in ["TRUE", "FALSE", "0", "0X0", "0X00", "1", "0X1", "0X01"]:\r
-            raise Warning("Unknown FvForceRebase value '%s'" % self.__Token, self.FileName, self.CurrentLineNumber)\r
-        \r
-        if self.__Token.upper() in ["TRUE", "1", "0X1", "0X01"]:\r
+        if self._Token.upper() in {"TRUE", "1", "0X1", "0X01"}:\r

             Obj.FvForceRebase = True\r
             Obj.FvForceRebase = True\r

-        elif self.__Token.upper() in ["FALSE", "0", "0X0", "0X00"]:\r
+        elif self._Token.upper() in {"FALSE", "0", "0X0", "0X00"}:\r

             Obj.FvForceRebase = False\r
         else:\r
             Obj.FvForceRebase = None\r
             Obj.FvForceRebase = False\r
         else:\r
             Obj.FvForceRebase = None\r

-           \r
+\r

         return True\r
 \r
 \r
         return True\r
 \r
 \r

-    ## __GetFvAttributes() method\r
+    ## _GetFvAttributes() method\r

     #\r
     #   Get attributes for FV\r
     #\r
     #\r
     #   Get attributes for FV\r
     #\r


@@ -2259,31 +2207,31 @@ class FdfParser:
     #   @param  Obj         for whom attribute is got\r
     #   @retval None\r
     #\r
     #   @param  Obj         for whom attribute is got\r
     #   @retval None\r
     #\r

-    def __GetFvAttributes(self, FvObj):\r
+    def _GetFvAttributes(self, FvObj):\r

         IsWordToken = False\r
         IsWordToken = False\r

-        while self.__GetNextWord():\r
+        while self._GetNextWord():\r

             IsWordToken = True\r
             IsWordToken = True\r

-            name = self.__Token\r
-            if name not in ("ERASE_POLARITY", "MEMORY_MAPPED", \\r
+            name = self._Token\r
+            if name not in {"ERASE_POLARITY", "MEMORY_MAPPED", \\r

                            "STICKY_WRITE", "LOCK_CAP", "LOCK_STATUS", "WRITE_ENABLED_CAP", \\r
                            "WRITE_DISABLED_CAP", "WRITE_STATUS", "READ_ENABLED_CAP", \\r
                            "READ_DISABLED_CAP", "READ_STATUS", "READ_LOCK_CAP", \\r
                            "READ_LOCK_STATUS", "WRITE_LOCK_CAP", "WRITE_LOCK_STATUS", \\r
                            "STICKY_WRITE", "LOCK_CAP", "LOCK_STATUS", "WRITE_ENABLED_CAP", \\r
                            "WRITE_DISABLED_CAP", "WRITE_STATUS", "READ_ENABLED_CAP", \\r
                            "READ_DISABLED_CAP", "READ_STATUS", "READ_LOCK_CAP", \\r
                            "READ_LOCK_STATUS", "WRITE_LOCK_CAP", "WRITE_LOCK_STATUS", \\r

-                           "WRITE_POLICY_RELIABLE", "WEAK_ALIGNMENT", "FvUsedSizeEnable"):\r
-                self.__UndoToken()\r
+                           "WRITE_POLICY_RELIABLE", "WEAK_ALIGNMENT", "FvUsedSizeEnable"}:\r
+                self._UndoToken()\r

                 return False\r
 \r
                 return False\r
 \r

-            if not self.__IsToken( "="):\r
-                raise Warning("expected '='", self.FileName, self.CurrentLineNumber)\r
+            if not self._IsToken(TAB_EQUAL_SPLIT):\r
+                raise Warning.ExpectedEquals(self.FileName, self.CurrentLineNumber)\r

 \r
 \r

-            if not self.__GetNextToken() or self.__Token.upper() not in ("TRUE", "FALSE", "1", "0"):\r
-                raise Warning("expected TRUE/FALSE (1/0)", self.FileName, self.CurrentLineNumber)\r
+            if not self._GetNextToken() or self._Token.upper() not in {"TRUE", "FALSE", "1", "0"}:\r
+                raise Warning.Expected("TRUE/FALSE (1/0)", self.FileName, self.CurrentLineNumber)\r

 \r
 \r

-            FvObj.FvAttributeDict[name] = self.__Token\r
+            FvObj.FvAttributeDict[name] = self._Token\r

 \r
         return IsWordToken\r
 \r
         return IsWordToken\r

-    \r
-    ## __GetFvNameGuid() method\r
+\r
+    ## _GetFvNameGuid() method\r

     #\r
     #   Get FV GUID for FV\r
     #\r
     #\r
     #   Get FV GUID for FV\r
     #\r


@@ -2291,176 +2239,172 @@ class FdfParser:
     #   @param  Obj         for whom GUID is got\r
     #   @retval None\r
     #\r
     #   @param  Obj         for whom GUID is got\r
     #   @retval None\r
     #\r

-    def __GetFvNameGuid(self, FvObj):\r
-\r
-        if not self.__IsKeyword( "FvNameGuid"):\r
+    def _GetFvNameGuid(self, FvObj):\r
+        if not self._IsKeyword("FvNameGuid"):\r

             return False\r
 \r
             return False\r
 \r

-        if not self.__IsToken( "="):\r
-            raise Warning("expected '='", self.FileName, self.CurrentLineNumber)\r
+        if not self._IsToken(TAB_EQUAL_SPLIT):\r
+            raise Warning.ExpectedEquals(self.FileName, self.CurrentLineNumber)\r

 \r
 \r

-        if not self.__GetNextGuid():\r
-            raise Warning("expected FV GUID value", self.FileName, self.CurrentLineNumber)\r
+        if not self._GetNextGuid():\r
+            raise Warning.Expected("GUID value", self.FileName, self.CurrentLineNumber)\r

 \r
 \r

-        FvObj.FvNameGuid = self.__Token\r
+        FvObj.FvNameGuid = self._Token\r

 \r
         return True\r
 \r
 \r
         return True\r
 \r

-    def __GetFvNameString(self, FvObj):\r
-\r
-        if not self.__IsKeyword( "FvNameString"):\r
+    def _GetFvNameString(self, FvObj):\r
+        if not self._IsKeyword("FvNameString"):\r

             return False\r
 \r
             return False\r
 \r

-        if not self.__IsToken( "="):\r
-            raise Warning("expected '='", self.FileName, self.CurrentLineNumber)\r
+        if not self._IsToken(TAB_EQUAL_SPLIT):\r
+            raise Warning.ExpectedEquals(self.FileName, self.CurrentLineNumber)\r

 \r
 \r

-        if not self.__GetNextToken() or self.__Token not in ('TRUE', 'FALSE'):\r
-            raise Warning("expected TRUE or FALSE for FvNameString", self.FileName, self.CurrentLineNumber)\r
+        if not self._GetNextToken() or self._Token.upper() not in {'TRUE', 'FALSE'}:\r
+            raise Warning.Expected("TRUE or FALSE for FvNameString", self.FileName, self.CurrentLineNumber)\r

 \r
 \r

-        FvObj.FvNameString = self.__Token\r
+        FvObj.FvNameString = self._Token\r

 \r
         return True\r
 \r
 \r
         return True\r
 \r

-    def __GetFvExtEntryStatement(self, FvObj):\r
-\r
-        if not (self.__IsKeyword( "FV_EXT_ENTRY") or self.__IsKeyword( "FV_EXT_ENTRY_TYPE")):\r
+    def _GetFvExtEntryStatement(self, FvObj):\r
+        if not (self._IsKeyword("FV_EXT_ENTRY") or self._IsKeyword("FV_EXT_ENTRY_TYPE")):\r

             return False\r
 \r
             return False\r
 \r

-        if not self.__IsKeyword ("TYPE"):\r
-            raise Warning("expected 'TYPE'", self.FileName, self.CurrentLineNumber)\r
-            \r
-        if not self.__IsToken( "="):\r
-            raise Warning("expected '='", self.FileName, self.CurrentLineNumber)\r
+        if not self._IsKeyword ("TYPE"):\r
+            raise Warning.Expected("'TYPE'", self.FileName, self.CurrentLineNumber)\r

 \r
 \r

-        if not self.__GetNextHexNumber() and not self.__GetNextDecimalNumber():\r
-            raise Warning("expected Hex FV extension entry type value At Line ", self.FileName, self.CurrentLineNumber)\r
+        if not self._IsToken(TAB_EQUAL_SPLIT):\r
+            raise Warning.ExpectedEquals(self.FileName, self.CurrentLineNumber)\r

 \r
 \r

-        FvObj.FvExtEntryTypeValue += [self.__Token]\r
+        if not self._GetNextHexNumber() and not self._GetNextDecimalNumber():\r
+            raise Warning.Expected("Hex FV extension entry type value At Line ", self.FileName, self.CurrentLineNumber)\r

 \r
 \r

-        if not self.__IsToken( "{"):\r
-            raise Warning("expected '{'", self.FileName, self.CurrentLineNumber)\r
+        FvObj.FvExtEntryTypeValue.append(self._Token)\r

 \r
 \r

-        if not self.__IsKeyword ("FILE") and not self.__IsKeyword ("DATA"):\r
-            raise Warning("expected 'FILE' or 'DATA'", self.FileName, self.CurrentLineNumber)\r
+        if not self._IsToken("{"):\r
+            raise Warning.ExpectedCurlyOpen(self.FileName, self.CurrentLineNumber)\r

 \r
 \r

-        FvObj.FvExtEntryType += [self.__Token]\r
+        if not self._IsKeyword("FILE") and not self._IsKeyword("DATA"):\r
+            raise Warning.Expected("'FILE' or 'DATA'", self.FileName, self.CurrentLineNumber)\r

 \r
 \r

-        if self.__Token == 'DATA':\r
+        FvObj.FvExtEntryType.append(self._Token)\r

 \r
 \r

-            if not self.__IsToken( "="):\r
-                raise Warning("expected '='", self.FileName, self.CurrentLineNumber)\r
-                \r
-            if not self.__IsToken( "{"):\r
-                raise Warning("expected '{'", self.FileName, self.CurrentLineNumber)\r
+        if self._Token == 'DATA':\r
+            if not self._IsToken(TAB_EQUAL_SPLIT):\r
+                raise Warning.ExpectedEquals(self.FileName, self.CurrentLineNumber)\r

 \r
 \r

-            if not self.__GetNextHexNumber():\r
-                raise Warning("expected Hex byte", self.FileName, self.CurrentLineNumber)\r
+            if not self._IsToken("{"):\r
+                raise Warning.ExpectedCurlyOpen(self.FileName, self.CurrentLineNumber)\r

 \r
 \r

-            if len(self.__Token) > 4:\r
+            if not self._GetNextHexNumber():\r
+                raise Warning.Expected("Hex byte", self.FileName, self.CurrentLineNumber)\r
+\r
+            if len(self._Token) > 4:\r

                 raise Warning("Hex byte(must be 2 digits) too long", self.FileName, self.CurrentLineNumber)\r
 \r
                 raise Warning("Hex byte(must be 2 digits) too long", self.FileName, self.CurrentLineNumber)\r
 \r

-            DataString = self.__Token\r
-            DataString += ","\r
+            DataString = self._Token\r
+            DataString += TAB_COMMA_SPLIT\r

 \r
 \r

-            while self.__IsToken(","):\r
-                if not self.__GetNextHexNumber():\r
+            while self._IsToken(TAB_COMMA_SPLIT):\r
+                if not self._GetNextHexNumber():\r

                     raise Warning("Invalid Hex number", self.FileName, self.CurrentLineNumber)\r
                     raise Warning("Invalid Hex number", self.FileName, self.CurrentLineNumber)\r

-                if len(self.__Token) > 4:\r
+                if len(self._Token) > 4:\r

                     raise Warning("Hex byte(must be 2 digits) too long", self.FileName, self.CurrentLineNumber)\r
                     raise Warning("Hex byte(must be 2 digits) too long", self.FileName, self.CurrentLineNumber)\r

-                DataString += self.__Token\r
-                DataString += ","\r
+                DataString += self._Token\r
+                DataString += TAB_COMMA_SPLIT\r
+\r
+            if not self._IsToken(T_CHAR_BRACE_R):\r
+                raise Warning.ExpectedCurlyClose(self.FileName, self.CurrentLineNumber)\r

 \r
 \r

-            if not self.__IsToken( "}"):\r
-                raise Warning("expected '}'", self.FileName, self.CurrentLineNumber)\r
+            if not self._IsToken(T_CHAR_BRACE_R):\r
+                raise Warning.ExpectedCurlyClose(self.FileName, self.CurrentLineNumber)\r

 \r
 \r

-            if not self.__IsToken( "}"):\r
-                raise Warning("expected '}'", self.FileName, self.CurrentLineNumber)\r
+            DataString = DataString.rstrip(TAB_COMMA_SPLIT)\r
+            FvObj.FvExtEntryData.append(DataString)\r

 \r
 \r

-            DataString = DataString.rstrip(",")\r
-            FvObj.FvExtEntryData += [DataString]\r
+        if self._Token == 'FILE':\r
+            if not self._IsToken(TAB_EQUAL_SPLIT):\r
+                raise Warning.ExpectedEquals(self.FileName, self.CurrentLineNumber)\r

 \r
 \r

-        if self.__Token == 'FILE':\r
-        \r
-            if not self.__IsToken( "="):\r
-                raise Warning("expected '='", self.FileName, self.CurrentLineNumber)\r
-                \r
-            if not self.__GetNextToken():\r
-                raise Warning("expected FV Extension Entry file path At Line ", self.FileName, self.CurrentLineNumber)\r
-                \r
-            FvObj.FvExtEntryData += [self.__Token]\r
+            if not self._GetNextToken():\r
+                raise Warning.Expected("FV Extension Entry file path At Line ", self.FileName, self.CurrentLineNumber)\r

 \r
 \r

-            if not self.__IsToken( "}"):\r
-                raise Warning("expected '}'", self.FileName, self.CurrentLineNumber)\r
+            FvObj.FvExtEntryData.append(self._Token)\r
+\r
+            if not self._IsToken(T_CHAR_BRACE_R):\r
+                raise Warning.ExpectedCurlyClose(self.FileName, self.CurrentLineNumber)\r

 \r
         return True\r
 \r
 \r
         return True\r
 \r

-    ## __GetAprioriSection() method\r
+    ## _GetAprioriSection() method\r

     #\r
     #   Get token statements\r
     #\r
     #   @param  self        The object pointer\r
     #   @param  FvObj       for whom apriori is got\r
     #\r
     #   Get token statements\r
     #\r
     #   @param  self        The object pointer\r
     #   @param  FvObj       for whom apriori is got\r

-    #   @param  MacroDict   dictionary used to replace macro\r

     #   @retval True        Successfully find apriori statement\r
     #   @retval False       Not able to find apriori statement\r
     #\r
     #   @retval True        Successfully find apriori statement\r
     #   @retval False       Not able to find apriori statement\r
     #\r

-    def __GetAprioriSection(self, FvObj, MacroDict = {}):\r
-\r
-        if not self.__IsKeyword( "APRIORI"):\r
+    def _GetAprioriSection(self, FvObj):\r
+        if not self._IsKeyword("APRIORI"):\r

             return False\r
 \r
             return False\r
 \r

-        if not self.__IsKeyword("PEI") and not self.__IsKeyword("DXE"):\r
-            raise Warning("expected Apriori file type", self.FileName, self.CurrentLineNumber)\r
-        AprType = self.__Token\r
+        if not self._IsKeyword("PEI") and not self._IsKeyword("DXE"):\r
+            raise Warning.Expected("Apriori file type", self.FileName, self.CurrentLineNumber)\r
+        AprType = self._Token\r

 \r
 \r

-        if not self.__IsToken( "{"):\r
-            raise Warning("expected '{'", self.FileName, self.CurrentLineNumber)\r
+        if not self._IsToken("{"):\r
+            raise Warning.ExpectedCurlyOpen(self.FileName, self.CurrentLineNumber)\r

 \r
 \r

-        AprSectionObj = AprioriSection.AprioriSection()\r
+        AprSectionObj = AprioriSection()\r

         AprSectionObj.AprioriType = AprType\r
 \r
         AprSectionObj.AprioriType = AprType\r
 \r

-        self.__GetDefineStatements(AprSectionObj)\r
-        MacroDict.update(AprSectionObj.DefineVarDict)\r
+        self._GetDefineStatements(AprSectionObj)\r

 \r
         while True:\r
 \r
         while True:\r

-            IsInf = self.__GetInfStatement( AprSectionObj, MacroDict = MacroDict)\r
-            IsFile = self.__GetFileStatement( AprSectionObj)\r
+            IsInf = self._GetInfStatement(AprSectionObj)\r
+            IsFile = self._GetFileStatement(AprSectionObj)\r

             if not IsInf and not IsFile:\r
                 break\r
 \r
             if not IsInf and not IsFile:\r
                 break\r
 \r

-        if not self.__IsToken( "}"):\r
-            raise Warning("expected '}'", self.FileName, self.CurrentLineNumber)\r
+        if not self._IsToken(T_CHAR_BRACE_R):\r
+            raise Warning.ExpectedCurlyClose(self.FileName, self.CurrentLineNumber)\r

 \r
         FvObj.AprioriSectionList.append(AprSectionObj)\r
         return True\r
 \r
 \r
         FvObj.AprioriSectionList.append(AprSectionObj)\r
         return True\r
 \r

-    def __ParseInfStatement(self):\r
-        if not self.__IsKeyword("INF"):\r
+    def _ParseInfStatement(self):\r
+        if not self._IsKeyword("INF"):\r

             return None\r
 \r
             return None\r
 \r

-        ffsInf = FfsInfStatement.FfsInfStatement()\r
-        self.__GetInfOptions(ffsInf)\r
+        ffsInf = FfsInfStatement()\r
+        self._GetInfOptions(ffsInf)\r

 \r
 \r

-        if not self.__GetNextToken():\r
-            raise Warning("expected INF file path", self.FileName, self.CurrentLineNumber)\r
-        ffsInf.InfFileName = self.__Token\r
+        if not self._GetNextToken():\r
+            raise Warning.Expected("INF file path", self.FileName, self.CurrentLineNumber)\r
+        ffsInf.InfFileName = self._Token\r

         if not ffsInf.InfFileName.endswith('.inf'):\r
         if not ffsInf.InfFileName.endswith('.inf'):\r

-            raise Warning("expected .inf file path", self.FileName, self.CurrentLineNumber)\r
+            raise Warning.Expected(".inf file path", self.FileName, self.CurrentLineNumber)\r

 \r
         ffsInf.CurrentLineNum = self.CurrentLineNumber\r
 \r
         ffsInf.CurrentLineNum = self.CurrentLineNumber\r

-        ffsInf.CurrentLineContent = self.__CurrentLine()\r
+        ffsInf.CurrentLineContent = self._CurrentLine()\r

 \r
         #Replace $(SAPCE) with real space\r
         ffsInf.InfFileName = ffsInf.InfFileName.replace('$(SPACE)', ' ')\r
 \r
 \r
         #Replace $(SAPCE) with real space\r
         ffsInf.InfFileName = ffsInf.InfFileName.replace('$(SPACE)', ' ')\r
 \r

-        if ffsInf.InfFileName.replace('$(WORKSPACE)', '').find('$') == -1:\r
+        if ffsInf.InfFileName.replace(TAB_WORKSPACE, '').find('$') == -1:\r

             #do case sensitive check for file path\r
             ErrorCode, ErrorInfo = PathClass(NormPath(ffsInf.InfFileName), GenFdsGlobalVariable.WorkSpaceDir).Validate()\r
             if ErrorCode != 0:\r
                 EdkLogger.error("GenFds", ErrorCode, ExtraData=ErrorInfo)\r
 \r
             #do case sensitive check for file path\r
             ErrorCode, ErrorInfo = PathClass(NormPath(ffsInf.InfFileName), GenFdsGlobalVariable.WorkSpaceDir).Validate()\r
             if ErrorCode != 0:\r
                 EdkLogger.error("GenFds", ErrorCode, ExtraData=ErrorInfo)\r
 \r

-        if not ffsInf.InfFileName in self.Profile.InfList:\r
-            self.Profile.InfList.append(ffsInf.InfFileName)\r
+        NewFileName = ffsInf.InfFileName\r
+        if ffsInf.OverrideGuid:\r
+            NewFileName = ProcessDuplicatedInf(PathClass(ffsInf.InfFileName,GenFdsGlobalVariable.WorkSpaceDir), ffsInf.OverrideGuid, GenFdsGlobalVariable.WorkSpaceDir).Path\r
+\r
+        if not NewFileName in self.Profile.InfList:\r
+            self.Profile.InfList.append(NewFileName)\r

             FileLineTuple = GetRealFileLine(self.FileName, self.CurrentLineNumber)\r
             self.Profile.InfFileLineList.append(FileLineTuple)\r
             if ffsInf.UseArch:\r
             FileLineTuple = GetRealFileLine(self.FileName, self.CurrentLineNumber)\r
             self.Profile.InfFileLineList.append(FileLineTuple)\r
             if ffsInf.UseArch:\r


@@ -2471,150 +2415,147 @@ class FdfParser:
             else:\r
                 self.Profile.InfDict['ArchTBD'].append(ffsInf.InfFileName)\r
 \r
             else:\r
                 self.Profile.InfDict['ArchTBD'].append(ffsInf.InfFileName)\r
 \r

-        if self.__IsToken('|'):\r
-            if self.__IsKeyword('RELOCS_STRIPPED'):\r
+        if self._IsToken(TAB_VALUE_SPLIT):\r
+            if self._IsKeyword('RELOCS_STRIPPED'):\r

                 ffsInf.KeepReloc = False\r
                 ffsInf.KeepReloc = False\r

-            elif self.__IsKeyword('RELOCS_RETAINED'):\r
+            elif self._IsKeyword('RELOCS_RETAINED'):\r

                 ffsInf.KeepReloc = True\r
             else:\r
                 ffsInf.KeepReloc = True\r
             else:\r

-                raise Warning("Unknown reloc strip flag '%s'" % self.__Token, self.FileName, self.CurrentLineNumber)\r
+                raise Warning("Unknown reloc strip flag '%s'" % self._Token, self.FileName, self.CurrentLineNumber)\r

         return ffsInf\r
 \r
         return ffsInf\r
 \r

-    ## __GetInfStatement() method\r
+    ## _GetInfStatement() method\r

     #\r
     #   Get INF statements\r
     #\r
     #   @param  self        The object pointer\r
     #   @param  Obj         for whom inf statement is got\r
     #\r
     #   Get INF statements\r
     #\r
     #   @param  self        The object pointer\r
     #   @param  Obj         for whom inf statement is got\r

-    #   @param  MacroDict   dictionary used to replace macro\r

     #   @retval True        Successfully find inf statement\r
     #   @retval False       Not able to find inf statement\r
     #\r
     #   @retval True        Successfully find inf statement\r
     #   @retval False       Not able to find inf statement\r
     #\r

-    def __GetInfStatement(self, Obj, ForCapsule=False, MacroDict={}):\r
-        ffsInf = self.__ParseInfStatement()\r
+    def _GetInfStatement(self, Obj, ForCapsule=False):\r
+        ffsInf = self._ParseInfStatement()\r

         if not ffsInf:\r
             return False\r
 \r
         if ForCapsule:\r
         if not ffsInf:\r
             return False\r
 \r
         if ForCapsule:\r

-            capsuleFfs = CapsuleData.CapsuleFfs()\r
-            capsuleFfs.Ffs = ffsInf\r
-            Obj.CapsuleDataList.append(capsuleFfs)\r
+            myCapsuleFfs = CapsuleFfs()\r
+            myCapsuleFfs.Ffs = ffsInf\r
+            Obj.CapsuleDataList.append(myCapsuleFfs)\r

         else:\r
             Obj.FfsList.append(ffsInf)\r
         return True\r
 \r
         else:\r
             Obj.FfsList.append(ffsInf)\r
         return True\r
 \r

-    ## __GetInfOptions() method\r
+    ## _GetInfOptions() method\r

     #\r
     #   Get options for INF\r
     #\r
     #   @param  self        The object pointer\r
     #   @param  FfsInfObj   for whom option is got\r
     #\r
     #\r
     #   Get options for INF\r
     #\r
     #   @param  self        The object pointer\r
     #   @param  FfsInfObj   for whom option is got\r
     #\r

-    def __GetInfOptions(self, FfsInfObj):\r
-        if self.__IsKeyword("FILE_GUID"):\r
-            if not self.__IsToken("="):\r
-                raise Warning("expected '='", self.FileName, self.CurrentLineNumber)\r
-            if not self.__GetNextGuid():\r
-                raise Warning("expected GUID value", self.FileName, self.CurrentLineNumber)\r
-            FfsInfObj.OverrideGuid = self.__Token\r
-\r
-        if self.__IsKeyword( "RuleOverride"):\r
-            if not self.__IsToken( "="):\r
-                raise Warning("expected '='", self.FileName, self.CurrentLineNumber)\r
-            if not self.__GetNextToken():\r
-                raise Warning("expected Rule name", self.FileName, self.CurrentLineNumber)\r
-            FfsInfObj.Rule = self.__Token\r
-\r
-        if self.__IsKeyword( "VERSION"):\r
-            if not self.__IsToken( "="):\r
-                raise Warning("expected '='", self.FileName, self.CurrentLineNumber)\r
-            if not self.__GetNextToken():\r
-                raise Warning("expected Version", self.FileName, self.CurrentLineNumber)\r
-\r
-            if self.__GetStringData():\r
-                FfsInfObj.Version = self.__Token\r
-\r
-        if self.__IsKeyword( "UI"):\r
-            if not self.__IsToken( "="):\r
-                raise Warning("expected '='", self.FileName, self.CurrentLineNumber)\r
-            if not self.__GetNextToken():\r
-                raise Warning("expected UI name", self.FileName, self.CurrentLineNumber)\r
-\r
-            if self.__GetStringData():\r
-                FfsInfObj.Ui = self.__Token\r
-\r
-        if self.__IsKeyword( "USE"):\r
-            if not self.__IsToken( "="):\r
-                raise Warning("expected '='", self.FileName, self.CurrentLineNumber)\r
-            if not self.__GetNextToken():\r
-                raise Warning("expected ARCH name", self.FileName, self.CurrentLineNumber)\r
-            FfsInfObj.UseArch = self.__Token\r
-\r
-                \r
-        if self.__GetNextToken():\r
-            p = re.compile(r'([a-zA-Z0-9\-]+|\$\(TARGET\)|\*)_([a-zA-Z0-9\-]+|\$\(TOOL_CHAIN_TAG\)|\*)_([a-zA-Z0-9\-]+|\$\(ARCH\))')\r
-            if p.match(self.__Token) and p.match(self.__Token).span()[1] == len(self.__Token):\r
-                FfsInfObj.KeyStringList.append(self.__Token)\r
-                if not self.__IsToken(","):\r
+    def _GetInfOptions(self, FfsInfObj):\r
+        if self._IsKeyword("FILE_GUID"):\r
+            if not self._IsToken(TAB_EQUAL_SPLIT):\r
+                raise Warning.ExpectedEquals(self.FileName, self.CurrentLineNumber)\r
+            if not self._GetNextGuid():\r
+                raise Warning.Expected("GUID value", self.FileName, self.CurrentLineNumber)\r
+            FfsInfObj.OverrideGuid = self._Token\r
+\r
+        if self._IsKeyword("RuleOverride"):\r
+            if not self._IsToken(TAB_EQUAL_SPLIT):\r
+                raise Warning.ExpectedEquals(self.FileName, self.CurrentLineNumber)\r
+            if not self._GetNextToken():\r
+                raise Warning.Expected("Rule name", self.FileName, self.CurrentLineNumber)\r
+            FfsInfObj.Rule = self._Token\r
+\r
+        if self._IsKeyword("VERSION"):\r
+            if not self._IsToken(TAB_EQUAL_SPLIT):\r
+                raise Warning.ExpectedEquals(self.FileName, self.CurrentLineNumber)\r
+            if not self._GetNextToken():\r
+                raise Warning.Expected("Version", self.FileName, self.CurrentLineNumber)\r
+\r
+            if self._GetStringData():\r
+                FfsInfObj.Version = self._Token\r
+\r
+        if self._IsKeyword(BINARY_FILE_TYPE_UI):\r
+            if not self._IsToken(TAB_EQUAL_SPLIT):\r
+                raise Warning.ExpectedEquals(self.FileName, self.CurrentLineNumber)\r
+            if not self._GetNextToken():\r
+                raise Warning.Expected("UI name", self.FileName, self.CurrentLineNumber)\r
+\r
+            if self._GetStringData():\r
+                FfsInfObj.Ui = self._Token\r
+\r
+        if self._IsKeyword("USE"):\r
+            if not self._IsToken(TAB_EQUAL_SPLIT):\r
+                raise Warning.ExpectedEquals(self.FileName, self.CurrentLineNumber)\r
+            if not self._GetNextToken():\r
+                raise Warning.Expected("ARCH name", self.FileName, self.CurrentLineNumber)\r
+            FfsInfObj.UseArch = self._Token\r
+\r
+\r
+        if self._GetNextToken():\r
+            p = compile(r'([a-zA-Z0-9\-]+|\$\(TARGET\)|\*)_([a-zA-Z0-9\-]+|\$\(TOOL_CHAIN_TAG\)|\*)_([a-zA-Z0-9\-]+|\$\(ARCH\))')\r
+            if p.match(self._Token) and p.match(self._Token).span()[1] == len(self._Token):\r
+                FfsInfObj.KeyStringList.append(self._Token)\r
+                if not self._IsToken(TAB_COMMA_SPLIT):\r

                     return\r
             else:\r
                     return\r
             else:\r

-                self.__UndoToken()\r
+                self._UndoToken()\r

                 return\r
 \r
                 return\r
 \r

-            while self.__GetNextToken():\r
-                if not p.match(self.__Token):\r
-                    raise Warning("expected KeyString \"Target_Tag_Arch\"", self.FileName, self.CurrentLineNumber)\r
-                FfsInfObj.KeyStringList.append(self.__Token)\r
+            while self._GetNextToken():\r
+                if not p.match(self._Token):\r
+                    raise Warning.Expected("KeyString \"Target_Tag_Arch\"", self.FileName, self.CurrentLineNumber)\r
+                FfsInfObj.KeyStringList.append(self._Token)\r

 \r
 \r

-                if not self.__IsToken(","):\r
+                if not self._IsToken(TAB_COMMA_SPLIT):\r

                     break\r
 \r
                     break\r
 \r

-    ## __GetFileStatement() method\r
+    ## _GetFileStatement() method\r

     #\r
     #   Get FILE statements\r
     #\r
     #   @param  self        The object pointer\r
     #   @param  Obj         for whom FILE statement is got\r
     #\r
     #   Get FILE statements\r
     #\r
     #   @param  self        The object pointer\r
     #   @param  Obj         for whom FILE statement is got\r

-    #   @param  MacroDict   dictionary used to replace macro\r

     #   @retval True        Successfully find FILE statement\r
     #   @retval False       Not able to find FILE statement\r
     #\r
     #   @retval True        Successfully find FILE statement\r
     #   @retval False       Not able to find FILE statement\r
     #\r

-    def __GetFileStatement(self, Obj, ForCapsule = False, MacroDict = {}):\r
-\r
-        if not self.__IsKeyword( "FILE"):\r
+    def _GetFileStatement(self, Obj, ForCapsule = False):\r
+        if not self._IsKeyword("FILE"):\r

             return False\r
 \r
             return False\r
 \r

-        if not self.__GetNextWord():\r
-            raise Warning("expected FFS type", self.FileName, self.CurrentLineNumber)\r
+        if not self._GetNextWord():\r
+            raise Warning.Expected("FFS type", self.FileName, self.CurrentLineNumber)\r

 \r
 \r

-        if ForCapsule and self.__Token == 'DATA':\r
-            self.__UndoToken()\r
-            self.__UndoToken()\r
+        if ForCapsule and self._Token == 'DATA':\r
+            self._UndoToken()\r
+            self._UndoToken()\r

             return False\r
             return False\r

-        \r
-        FfsFileObj = FfsFileStatement.FileStatement()\r
-        FfsFileObj.FvFileType = self.__Token\r
-\r
-        if not self.__IsToken( "="):\r
-            raise Warning("expected '='", self.FileName, self.CurrentLineNumber)\r
-\r
-        if not self.__GetNextGuid():\r
-            if not self.__GetNextWord():\r
-                raise Warning("expected File GUID", self.FileName, self.CurrentLineNumber)\r
-            if self.__Token == 'PCD':\r
-                if not self.__IsToken( "("):\r
-                    raise Warning("expected '('", self.FileName, self.CurrentLineNumber)\r
-                PcdPair = self.__GetNextPcdName()\r
-                if not self.__IsToken( ")"):\r
-                    raise Warning("expected ')'", self.FileName, self.CurrentLineNumber)\r
-                self.__Token = 'PCD('+PcdPair[1]+'.'+PcdPair[0]+')'\r
-                \r
-        FfsFileObj.NameGuid = self.__Token\r
-        \r
-        self.__GetFilePart( FfsFileObj, MacroDict.copy())\r
+\r
+        FfsFileObj = FileStatement()\r
+        FfsFileObj.FvFileType = self._Token\r
+\r
+        if not self._IsToken(TAB_EQUAL_SPLIT):\r
+            raise Warning.ExpectedEquals(self.FileName, self.CurrentLineNumber)\r
+\r
+        if not self._GetNextGuid():\r
+            if not self._GetNextWord():\r
+                raise Warning.Expected("File GUID", self.FileName, self.CurrentLineNumber)\r
+            if self._Token == 'PCD':\r
+                if not self._IsToken("("):\r
+                    raise Warning.Expected("'('", self.FileName, self.CurrentLineNumber)\r
+                PcdPair = self._GetNextPcdSettings()\r
+                if not self._IsToken(")"):\r
+                    raise Warning.Expected("')'", self.FileName, self.CurrentLineNumber)\r
+                self._Token = 'PCD('+PcdPair[1]+TAB_SPLIT+PcdPair[0]+')'\r
+\r
+        FfsFileObj.NameGuid = self._Token\r
+\r
+        self._GetFilePart(FfsFileObj)\r

 \r
         if ForCapsule:\r
 \r
         if ForCapsule:\r

-            capsuleFfs = CapsuleData.CapsuleFfs()\r
+            capsuleFfs = CapsuleFfs()\r

             capsuleFfs.Ffs = FfsFileObj\r
             Obj.CapsuleDataList.append(capsuleFfs)\r
         else:\r
             capsuleFfs.Ffs = FfsFileObj\r
             Obj.CapsuleDataList.append(capsuleFfs)\r
         else:\r


@@ -2622,7 +2563,7 @@ class FdfParser:
 \r
         return True\r
 \r
 \r
         return True\r
 \r

-    ## __FileCouldHaveRelocFlag() method\r
+    ## _FileCouldHaveRelocFlag() method\r

     #\r
     #   Check whether reloc strip flag can be set for a file type.\r
     #\r
     #\r
     #   Check whether reloc strip flag can be set for a file type.\r
     #\r


@@ -2631,13 +2572,13 @@ class FdfParser:
     #   @retval False       No way to have it\r
     #\r
     @staticmethod\r
     #   @retval False       No way to have it\r
     #\r
     @staticmethod\r

-    def __FileCouldHaveRelocFlag (FileType):\r
-        if FileType in ('SEC', 'PEI_CORE', 'PEIM', 'PEI_DXE_COMBO'):\r
+    def _FileCouldHaveRelocFlag (FileType):\r
+        if FileType in {SUP_MODULE_SEC, SUP_MODULE_PEI_CORE, SUP_MODULE_PEIM, SUP_MODULE_MM_CORE_STANDALONE, 'PEI_DXE_COMBO'}:\r

             return True\r
         else:\r
             return False\r
 \r
             return True\r
         else:\r
             return False\r
 \r

-    ## __SectionCouldHaveRelocFlag() method\r
+    ## _SectionCouldHaveRelocFlag() method\r

     #\r
     #   Check whether reloc strip flag can be set for a section type.\r
     #\r
     #\r
     #   Check whether reloc strip flag can be set for a section type.\r
     #\r


@@ -2646,106 +2587,102 @@ class FdfParser:
     #   @retval False       No way to have it\r
     #\r
     @staticmethod\r
     #   @retval False       No way to have it\r
     #\r
     @staticmethod\r

-    def __SectionCouldHaveRelocFlag (SectionType):\r
-        if SectionType in ('TE', 'PE32'):\r
+    def _SectionCouldHaveRelocFlag (SectionType):\r
+        if SectionType in {BINARY_FILE_TYPE_TE, BINARY_FILE_TYPE_PE32}:\r

             return True\r
         else:\r
             return False\r
 \r
             return True\r
         else:\r
             return False\r
 \r

-    ## __GetFilePart() method\r
+    ## _GetFilePart() method\r

     #\r
     #   Get components for FILE statement\r
     #\r
     #   @param  self        The object pointer\r
     #   @param  FfsFileObj   for whom component is got\r
     #\r
     #   Get components for FILE statement\r
     #\r
     #   @param  self        The object pointer\r
     #   @param  FfsFileObj   for whom component is got\r

-    #   @param  MacroDict   dictionary used to replace macro\r

     #\r
     #\r

-    def __GetFilePart(self, FfsFileObj, MacroDict = {}):\r
-\r
-        self.__GetFileOpts( FfsFileObj)\r
+    def _GetFilePart(self, FfsFileObj):\r
+        self._GetFileOpts(FfsFileObj)\r

 \r
 \r

-        if not self.__IsToken("{"):\r
-            if self.__IsKeyword('RELOCS_STRIPPED') or self.__IsKeyword('RELOCS_RETAINED'):\r
-                if self.__FileCouldHaveRelocFlag(FfsFileObj.FvFileType):\r
-                    if self.__Token == 'RELOCS_STRIPPED':\r
+        if not self._IsToken("{"):\r
+            if self._IsKeyword('RELOCS_STRIPPED') or self._IsKeyword('RELOCS_RETAINED'):\r
+                if self._FileCouldHaveRelocFlag(FfsFileObj.FvFileType):\r
+                    if self._Token == 'RELOCS_STRIPPED':\r

                         FfsFileObj.KeepReloc = False\r
                     else:\r
                         FfsFileObj.KeepReloc = True\r
                 else:\r
                     raise Warning("File type %s could not have reloc strip flag%d" % (FfsFileObj.FvFileType, self.CurrentLineNumber), self.FileName, self.CurrentLineNumber)\r
 \r
                         FfsFileObj.KeepReloc = False\r
                     else:\r
                         FfsFileObj.KeepReloc = True\r
                 else:\r
                     raise Warning("File type %s could not have reloc strip flag%d" % (FfsFileObj.FvFileType, self.CurrentLineNumber), self.FileName, self.CurrentLineNumber)\r
 \r

-            if not self.__IsToken("{"):\r
-                raise Warning("expected '{'", self.FileName, self.CurrentLineNumber)\r
+            if not self._IsToken("{"):\r
+                raise Warning.ExpectedCurlyOpen(self.FileName, self.CurrentLineNumber)\r

 \r
 \r

-        if not self.__GetNextToken():\r
-            raise Warning("expected File name or section data", self.FileName, self.CurrentLineNumber)\r
+        if not self._GetNextToken():\r
+            raise Warning.Expected("File name or section data", self.FileName, self.CurrentLineNumber)\r

 \r
 \r

-        if self.__Token == "FV":\r
-            if not self.__IsToken( "="):\r
-                raise Warning("expected '='", self.FileName, self.CurrentLineNumber)\r
-            if not self.__GetNextToken():\r
-                raise Warning("expected FV name", self.FileName, self.CurrentLineNumber)\r
-            FfsFileObj.FvName = self.__Token\r
+        if self._Token == BINARY_FILE_TYPE_FV:\r
+            if not self._IsToken(TAB_EQUAL_SPLIT):\r
+                raise Warning.ExpectedEquals(self.FileName, self.CurrentLineNumber)\r
+            if not self._GetNextToken():\r
+                raise Warning.Expected("FV name", self.FileName, self.CurrentLineNumber)\r
+            FfsFileObj.FvName = self._Token\r

 \r
 \r

-        elif self.__Token == "FD":\r
-            if not self.__IsToken( "="):\r
-                raise Warning("expected '='", self.FileName, self.CurrentLineNumber)\r
-            if not self.__GetNextToken():\r
-                raise Warning("expected FD name", self.FileName, self.CurrentLineNumber)\r
-            FfsFileObj.FdName = self.__Token\r
+        elif self._Token == "FD":\r
+            if not self._IsToken(TAB_EQUAL_SPLIT):\r
+                raise Warning.ExpectedEquals(self.FileName, self.CurrentLineNumber)\r
+            if not self._GetNextToken():\r
+                raise Warning.Expected("FD name", self.FileName, self.CurrentLineNumber)\r
+            FfsFileObj.FdName = self._Token\r

 \r
 \r

-        elif self.__Token in ("DEFINE", "APRIORI", "SECTION"):\r
-            self.__UndoToken()\r
-            self.__GetSectionData( FfsFileObj, MacroDict)\r
+        elif self._Token in {TAB_DEFINE, "APRIORI", "SECTION"}:\r
+            self._UndoToken()\r
+            self._GetSectionData(FfsFileObj)\r

 \r
         elif hasattr(FfsFileObj, 'FvFileType') and FfsFileObj.FvFileType == 'RAW':\r
 \r
         elif hasattr(FfsFileObj, 'FvFileType') and FfsFileObj.FvFileType == 'RAW':\r

-            self.__UndoToken()\r
-            self.__GetRAWData(FfsFileObj, MacroDict)\r
+            self._UndoToken()\r
+            self._GetRAWData(FfsFileObj)\r

 \r
         else:\r
             FfsFileObj.CurrentLineNum = self.CurrentLineNumber\r
 \r
         else:\r
             FfsFileObj.CurrentLineNum = self.CurrentLineNumber\r

-            FfsFileObj.CurrentLineContent = self.__CurrentLine()\r
-            FfsFileObj.FileName = self.__Token.replace('$(SPACE)', ' ')\r
-            self.__VerifyFile(FfsFileObj.FileName)\r
+            FfsFileObj.CurrentLineContent = self._CurrentLine()\r
+            FfsFileObj.FileName = self._Token.replace('$(SPACE)', ' ')\r
+            self._VerifyFile(FfsFileObj.FileName)\r

 \r
 \r

-        if not self.__IsToken( "}"):\r
-            raise Warning("expected '}'", self.FileName, self.CurrentLineNumber)\r
+        if not self._IsToken(T_CHAR_BRACE_R):\r
+            raise Warning.ExpectedCurlyClose(self.FileName, self.CurrentLineNumber)\r

 \r
 \r

-    ## __GetRAWData() method\r
+    ## _GetRAWData() method\r

     #\r
     #   Get RAW data for FILE statement\r
     #\r
     #   @param  self         The object pointer\r
     #   @param  FfsFileObj   for whom section is got\r
     #\r
     #   Get RAW data for FILE statement\r
     #\r
     #   @param  self         The object pointer\r
     #   @param  FfsFileObj   for whom section is got\r

-    #   @param  MacroDict    dictionary used to replace macro\r

     #\r
     #\r

-    def __GetRAWData(self, FfsFileObj, MacroDict = {}):\r
+    def _GetRAWData(self, FfsFileObj):\r

         FfsFileObj.FileName = []\r
         FfsFileObj.SubAlignment = []\r
         while True:\r
             AlignValue = None\r
         FfsFileObj.FileName = []\r
         FfsFileObj.SubAlignment = []\r
         while True:\r
             AlignValue = None\r

-            if self.__GetAlignment():\r
-                if self.__Token not in ("Auto", "8", "16", "32", "64", "128", "512", "1K", "4K", "32K" ,"64K", "128K",\r
-                                        "256K", "512K", "1M", "2M", "4M", "8M", "16M"):\r
-                    raise Warning("Incorrect alignment '%s'" % self.__Token, self.FileName, self.CurrentLineNumber)\r
+            if self._GetAlignment():\r
+                if self._Token not in ALIGNMENTS:\r
+                    raise Warning("Incorrect alignment '%s'" % self._Token, self.FileName, self.CurrentLineNumber)\r

                 #For FFS, Auto is default option same to ""\r
                 #For FFS, Auto is default option same to ""\r

-                if not self.__Token == "Auto":\r
-                    AlignValue = self.__Token\r
-            if not self.__GetNextToken():\r
-                raise Warning("expected Filename value", self.FileName, self.CurrentLineNumber)\r
+                if not self._Token == "Auto":\r
+                    AlignValue = self._Token\r
+            if not self._GetNextToken():\r
+                raise Warning.Expected("Filename value", self.FileName, self.CurrentLineNumber)\r

 \r
 \r

-            FileName = self.__Token.replace('$(SPACE)', ' ')\r
-            if FileName == '}':\r
-                self.__UndoToken()\r
-                raise Warning("expected Filename value", self.FileName, self.CurrentLineNumber)\r
+            FileName = self._Token.replace('$(SPACE)', ' ')\r
+            if FileName == T_CHAR_BRACE_R:\r
+                self._UndoToken()\r
+                raise Warning.Expected("Filename value", self.FileName, self.CurrentLineNumber)\r

 \r
 \r

-            self.__VerifyFile(FileName)\r
+            self._VerifyFile(FileName)\r

             File = PathClass(NormPath(FileName), GenFdsGlobalVariable.WorkSpaceDir)\r
             FfsFileObj.FileName.append(File.Path)\r
             FfsFileObj.SubAlignment.append(AlignValue)\r
 \r
             File = PathClass(NormPath(FileName), GenFdsGlobalVariable.WorkSpaceDir)\r
             FfsFileObj.FileName.append(File.Path)\r
             FfsFileObj.SubAlignment.append(AlignValue)\r
 \r

-            if self.__IsToken( "}"):\r
-                self.__UndoToken()\r
+            if self._IsToken(T_CHAR_BRACE_R):\r
+                self._UndoToken()\r

                 break\r
 \r
         if len(FfsFileObj.SubAlignment) == 1:\r
                 break\r
 \r
         if len(FfsFileObj.SubAlignment) == 1:\r


@@ -2753,45 +2690,43 @@ class FdfParser:
         if len(FfsFileObj.FileName) == 1:\r
             FfsFileObj.FileName = FfsFileObj.FileName[0]\r
 \r
         if len(FfsFileObj.FileName) == 1:\r
             FfsFileObj.FileName = FfsFileObj.FileName[0]\r
 \r

-    ## __GetFileOpts() method\r
+    ## _GetFileOpts() method\r

     #\r
     #   Get options for FILE statement\r
     #\r
     #   @param  self        The object pointer\r
     #   @param  FfsFileObj   for whom options is got\r
     #\r
     #\r
     #   Get options for FILE statement\r
     #\r
     #   @param  self        The object pointer\r
     #   @param  FfsFileObj   for whom options is got\r
     #\r

-    def __GetFileOpts(self, FfsFileObj):\r
-\r
-        if self.__GetNextToken():\r
-            if TokenFindPattern.match(self.__Token):\r
-                FfsFileObj.KeyStringList.append(self.__Token)\r
-                if self.__IsToken(","):\r
-                    while self.__GetNextToken():\r
-                        if not TokenFindPattern.match(self.__Token):\r
-                            raise Warning("expected KeyString \"Target_Tag_Arch\"", self.FileName, self.CurrentLineNumber)\r
-                        FfsFileObj.KeyStringList.append(self.__Token)\r
-\r
-                        if not self.__IsToken(","):\r
+    def _GetFileOpts(self, FfsFileObj):\r
+        if self._GetNextToken():\r
+            if TokenFindPattern.match(self._Token):\r
+                FfsFileObj.KeyStringList.append(self._Token)\r
+                if self._IsToken(TAB_COMMA_SPLIT):\r
+                    while self._GetNextToken():\r
+                        if not TokenFindPattern.match(self._Token):\r
+                            raise Warning.Expected("KeyString \"Target_Tag_Arch\"", self.FileName, self.CurrentLineNumber)\r
+                        FfsFileObj.KeyStringList.append(self._Token)\r
+\r
+                        if not self._IsToken(TAB_COMMA_SPLIT):\r

                             break\r
 \r
             else:\r
                             break\r
 \r
             else:\r

-                self.__UndoToken()\r
+                self._UndoToken()\r

 \r
 \r

-        if self.__IsKeyword( "FIXED", True):\r
+        if self._IsKeyword("FIXED", True):\r

             FfsFileObj.Fixed = True\r
 \r
             FfsFileObj.Fixed = True\r
 \r

-        if self.__IsKeyword( "CHECKSUM", True):\r
+        if self._IsKeyword("CHECKSUM", True):\r

             FfsFileObj.CheckSum = True\r
 \r
             FfsFileObj.CheckSum = True\r
 \r

-        if self.__GetAlignment():\r
-            if self.__Token not in ("Auto", "8", "16", "32", "64", "128", "512", "1K", "4K", "32K" ,"64K", "128K",\r
-                                    "256K", "512K", "1M", "2M", "4M", "8M", "16M"):\r
-                raise Warning("Incorrect alignment '%s'" % self.__Token, self.FileName, self.CurrentLineNumber)\r
+        if self._GetAlignment():\r
+            if self._Token not in ALIGNMENTS:\r
+                raise Warning("Incorrect alignment '%s'" % self._Token, self.FileName, self.CurrentLineNumber)\r

             #For FFS, Auto is default option same to ""\r
             #For FFS, Auto is default option same to ""\r

-            if not self.__Token == "Auto":\r
-                FfsFileObj.Alignment = self.__Token\r
+            if not self._Token == "Auto":\r
+                FfsFileObj.Alignment = self._Token\r

 \r
 \r

-    ## __GetAlignment() method\r
+    ## _GetAlignment() method\r

     #\r
     #   Return the alignment value\r
     #\r
     #\r
     #   Return the alignment value\r
     #\r


@@ -2799,142 +2734,129 @@ class FdfParser:
     #   @retval True        Successfully find alignment\r
     #   @retval False       Not able to find alignment\r
     #\r
     #   @retval True        Successfully find alignment\r
     #   @retval False       Not able to find alignment\r
     #\r

-    def __GetAlignment(self):\r
-        if self.__IsKeyword( "Align", True):\r
-            if not self.__IsToken( "="):\r
-                raise Warning("expected '='", self.FileName, self.CurrentLineNumber)\r
+    def _GetAlignment(self):\r
+        if self._IsKeyword("Align", True):\r
+            if not self._IsToken(TAB_EQUAL_SPLIT):\r
+                raise Warning.ExpectedEquals(self.FileName, self.CurrentLineNumber)\r

 \r
 \r

-            if not self.__GetNextToken():\r
-                raise Warning("expected alignment value", self.FileName, self.CurrentLineNumber)\r
+            if not self._GetNextToken():\r
+                raise Warning.Expected("alignment value", self.FileName, self.CurrentLineNumber)\r

             return True\r
 \r
         return False\r
 \r
             return True\r
 \r
         return False\r
 \r

-    ## __GetFilePart() method\r
+    ## _GetSectionData() method\r

     #\r
     #   Get section data for FILE statement\r
     #\r
     #   @param  self        The object pointer\r
     #   @param  FfsFileObj   for whom section is got\r
     #\r
     #   Get section data for FILE statement\r
     #\r
     #   @param  self        The object pointer\r
     #   @param  FfsFileObj   for whom section is got\r

-    #   @param  MacroDict   dictionary used to replace macro\r

     #\r
     #\r

-    def __GetSectionData(self, FfsFileObj, MacroDict = {}):\r
-        Dict = {}\r
-        Dict.update(MacroDict)\r
-\r
-        self.__GetDefineStatements(FfsFileObj)\r
-\r
-        Dict.update(FfsFileObj.DefineVarDict)\r
-        self.__GetAprioriSection(FfsFileObj, Dict.copy())\r
-        self.__GetAprioriSection(FfsFileObj, Dict.copy())\r
+    def _GetSectionData(self, FfsFileObj):\r
+        self._GetDefineStatements(FfsFileObj)\r

 \r
         while True:\r
 \r
         while True:\r

-            IsLeafSection = self.__GetLeafSection(FfsFileObj, Dict)\r
-            IsEncapSection = self.__GetEncapsulationSec(FfsFileObj)\r
+            IsLeafSection = self._GetLeafSection(FfsFileObj)\r
+            IsEncapSection = self._GetEncapsulationSec(FfsFileObj)\r

             if not IsLeafSection and not IsEncapSection:\r
                 break\r
 \r
             if not IsLeafSection and not IsEncapSection:\r
                 break\r
 \r

-    ## __GetLeafSection() method\r
+    ## _GetLeafSection() method\r

     #\r
     #   Get leaf section for Obj\r
     #\r
     #   @param  self        The object pointer\r
     #   @param  Obj         for whom leaf section is got\r
     #\r
     #   Get leaf section for Obj\r
     #\r
     #   @param  self        The object pointer\r
     #   @param  Obj         for whom leaf section is got\r

-    #   @param  MacroDict   dictionary used to replace macro\r

     #   @retval True        Successfully find section statement\r
     #   @retval False       Not able to find section statement\r
     #\r
     #   @retval True        Successfully find section statement\r
     #   @retval False       Not able to find section statement\r
     #\r

-    def __GetLeafSection(self, Obj, MacroDict = {}):\r
-\r
+    def _GetLeafSection(self, Obj):\r

         OldPos = self.GetFileBufferPos()\r
 \r
         OldPos = self.GetFileBufferPos()\r
 \r

-        if not self.__IsKeyword( "SECTION"):\r
+        if not self._IsKeyword("SECTION"):\r

             if len(Obj.SectionList) == 0:\r
             if len(Obj.SectionList) == 0:\r

-                raise Warning("expected SECTION", self.FileName, self.CurrentLineNumber)\r
+                raise Warning.Expected("SECTION", self.FileName, self.CurrentLineNumber)\r

             else:\r
                 return False\r
 \r
         AlignValue = None\r
             else:\r
                 return False\r
 \r
         AlignValue = None\r

-        if self.__GetAlignment():\r
-            if self.__Token not in ("Auto", "8", "16", "32", "64", "128", "512", "1K", "4K", "32K" ,"64K", "128K",\r
-                                    "256K", "512K", "1M", "2M", "4M", "8M", "16M"):\r
-                raise Warning("Incorrect alignment '%s'" % self.__Token, self.FileName, self.CurrentLineNumber)\r
-            AlignValue = self.__Token\r
+        if self._GetAlignment():\r
+            if self._Token not in ALIGNMENTS:\r
+                raise Warning("Incorrect alignment '%s'" % self._Token, self.FileName, self.CurrentLineNumber)\r
+            AlignValue = self._Token\r

 \r
         BuildNum = None\r
 \r
         BuildNum = None\r

-        if self.__IsKeyword( "BUILD_NUM"):\r
-            if not self.__IsToken( "="):\r
-                raise Warning("expected '='", self.FileName, self.CurrentLineNumber)\r
+        if self._IsKeyword("BUILD_NUM"):\r
+            if not self._IsToken(TAB_EQUAL_SPLIT):\r
+                raise Warning.ExpectedEquals(self.FileName, self.CurrentLineNumber)\r

 \r
 \r

-            if not self.__GetNextToken():\r
-                raise Warning("expected Build number value", self.FileName, self.CurrentLineNumber)\r
+            if not self._GetNextToken():\r
+                raise Warning.Expected("Build number value", self.FileName, self.CurrentLineNumber)\r

 \r
 \r

-            BuildNum = self.__Token\r
+            BuildNum = self._Token\r

 \r
 \r

-        if self.__IsKeyword( "VERSION"):\r
+        if self._IsKeyword("VERSION"):\r

             if AlignValue == 'Auto':\r
                 raise Warning("Auto alignment can only be used in PE32 or TE section ", self.FileName, self.CurrentLineNumber)\r
             if AlignValue == 'Auto':\r
                 raise Warning("Auto alignment can only be used in PE32 or TE section ", self.FileName, self.CurrentLineNumber)\r

-            if not self.__IsToken( "="):\r
-                raise Warning("expected '='", self.FileName, self.CurrentLineNumber)\r
-            if not self.__GetNextToken():\r
-                raise Warning("expected version", self.FileName, self.CurrentLineNumber)\r
-            VerSectionObj = VerSection.VerSection()\r
+            if not self._IsToken(TAB_EQUAL_SPLIT):\r
+                raise Warning.ExpectedEquals(self.FileName, self.CurrentLineNumber)\r
+            if not self._GetNextToken():\r
+                raise Warning.Expected("version", self.FileName, self.CurrentLineNumber)\r
+            VerSectionObj = VerSection()\r

             VerSectionObj.Alignment = AlignValue\r
             VerSectionObj.BuildNum = BuildNum\r
             VerSectionObj.Alignment = AlignValue\r
             VerSectionObj.BuildNum = BuildNum\r

-            if self.__GetStringData():\r
-                VerSectionObj.StringData = self.__Token\r
+            if self._GetStringData():\r
+                VerSectionObj.StringData = self._Token\r

             else:\r
             else:\r

-                VerSectionObj.FileName = self.__Token\r
+                VerSectionObj.FileName = self._Token\r

             Obj.SectionList.append(VerSectionObj)\r
             Obj.SectionList.append(VerSectionObj)\r

-            \r
-        elif self.__IsKeyword( "UI"):\r
+\r
+        elif self._IsKeyword(BINARY_FILE_TYPE_UI):\r

             if AlignValue == 'Auto':\r
                 raise Warning("Auto alignment can only be used in PE32 or TE section ", self.FileName, self.CurrentLineNumber)\r
             if AlignValue == 'Auto':\r
                 raise Warning("Auto alignment can only be used in PE32 or TE section ", self.FileName, self.CurrentLineNumber)\r

-            if not self.__IsToken( "="):\r
-                raise Warning("expected '='", self.FileName, self.CurrentLineNumber)\r
-            if not self.__GetNextToken():\r
-                raise Warning("expected UI", self.FileName, self.CurrentLineNumber)\r
-            UiSectionObj = UiSection.UiSection()\r
+            if not self._IsToken(TAB_EQUAL_SPLIT):\r
+                raise Warning.ExpectedEquals(self.FileName, self.CurrentLineNumber)\r
+            if not self._GetNextToken():\r
+                raise Warning.Expected("UI", self.FileName, self.CurrentLineNumber)\r
+            UiSectionObj = UiSection()\r

             UiSectionObj.Alignment = AlignValue\r
             UiSectionObj.Alignment = AlignValue\r

-            if self.__GetStringData():\r
-                UiSectionObj.StringData = self.__Token\r
+            if self._GetStringData():\r
+                UiSectionObj.StringData = self._Token\r

             else:\r
             else:\r

-                UiSectionObj.FileName = self.__Token\r
+                UiSectionObj.FileName = self._Token\r

             Obj.SectionList.append(UiSectionObj)\r
 \r
             Obj.SectionList.append(UiSectionObj)\r
 \r

-        elif self.__IsKeyword( "FV_IMAGE"):\r
+        elif self._IsKeyword("FV_IMAGE"):\r

             if AlignValue == 'Auto':\r
                 raise Warning("Auto alignment can only be used in PE32 or TE section ", self.FileName, self.CurrentLineNumber)\r
             if AlignValue == 'Auto':\r
                 raise Warning("Auto alignment can only be used in PE32 or TE section ", self.FileName, self.CurrentLineNumber)\r

-            if not self.__IsToken( "="):\r
-                raise Warning("expected '='", self.FileName, self.CurrentLineNumber)\r
-            if not self.__GetNextToken():\r
-                raise Warning("expected FV name or FV file path", self.FileName, self.CurrentLineNumber)\r
+            if not self._IsToken(TAB_EQUAL_SPLIT):\r
+                raise Warning.ExpectedEquals(self.FileName, self.CurrentLineNumber)\r
+            if not self._GetNextToken():\r
+                raise Warning.Expected("FV name or FV file path", self.FileName, self.CurrentLineNumber)\r

 \r
 \r

-            FvName = self.__Token\r
+            FvName = self._Token\r

             FvObj = None\r
 \r
             FvObj = None\r
 \r

-            if self.__IsToken( "{"):\r
-                FvObj = Fv.FV()\r
+            if self._IsToken("{"):\r
+                FvObj = FV()\r

                 FvObj.UiFvName = FvName.upper()\r
                 FvObj.UiFvName = FvName.upper()\r

-                self.__GetDefineStatements(FvObj)\r
-                MacroDict.update(FvObj.DefineVarDict)\r
-                self.__GetBlockStatement(FvObj)\r
-                self.__GetSetStatements(FvObj)\r
-                self.__GetFvAlignment(FvObj)\r
-                self.__GetFvAttributes(FvObj)\r
-                self.__GetAprioriSection(FvObj, MacroDict.copy())\r
-                self.__GetAprioriSection(FvObj, MacroDict.copy())\r
+                self._GetDefineStatements(FvObj)\r
+\r
+                self._GetBlockStatement(FvObj)\r
+                self._GetSetStatements(FvObj)\r
+                self._GetFvAlignment(FvObj)\r
+                self._GetFvAttributes(FvObj)\r

 \r
                 while True:\r
 \r
                 while True:\r

-                    IsInf = self.__GetInfStatement(FvObj, MacroDict.copy())\r
-                    IsFile = self.__GetFileStatement(FvObj, MacroDict.copy())\r
+                    IsInf = self._GetInfStatement(FvObj)\r
+                    IsFile = self._GetFileStatement(FvObj)\r

                     if not IsInf and not IsFile:\r
                         break\r
 \r
                     if not IsInf and not IsFile:\r
                         break\r
 \r

-                if not self.__IsToken( "}"):\r
-                    raise Warning("expected '}'", self.FileName, self.CurrentLineNumber)\r
+                if not self._IsToken(T_CHAR_BRACE_R):\r
+                    raise Warning.ExpectedCurlyClose(self.FileName, self.CurrentLineNumber)\r

 \r
 \r

-            FvImageSectionObj = FvImageSection.FvImageSection()\r
+            FvImageSectionObj = FvImageSection()\r

             FvImageSectionObj.Alignment = AlignValue\r
             if FvObj is not None:\r
                 FvImageSectionObj.Fv = FvObj\r
             FvImageSectionObj.Alignment = AlignValue\r
             if FvObj is not None:\r
                 FvImageSectionObj.Fv = FvObj\r


@@ -2945,81 +2867,81 @@ class FdfParser:
 \r
             Obj.SectionList.append(FvImageSectionObj)\r
 \r
 \r
             Obj.SectionList.append(FvImageSectionObj)\r
 \r

-        elif self.__IsKeyword("PEI_DEPEX_EXP") or self.__IsKeyword("DXE_DEPEX_EXP") or self.__IsKeyword("SMM_DEPEX_EXP"):\r
+        elif self._IsKeyword("PEI_DEPEX_EXP") or self._IsKeyword("DXE_DEPEX_EXP") or self._IsKeyword("SMM_DEPEX_EXP"):\r

             if AlignValue == 'Auto':\r
                 raise Warning("Auto alignment can only be used in PE32 or TE section ", self.FileName, self.CurrentLineNumber)\r
             if AlignValue == 'Auto':\r
                 raise Warning("Auto alignment can only be used in PE32 or TE section ", self.FileName, self.CurrentLineNumber)\r

-            DepexSectionObj = DepexSection.DepexSection()\r
+            DepexSectionObj = DepexSection()\r

             DepexSectionObj.Alignment = AlignValue\r
             DepexSectionObj.Alignment = AlignValue\r

-            DepexSectionObj.DepexType = self.__Token\r
+            DepexSectionObj.DepexType = self._Token\r

 \r
 \r

-            if not self.__IsToken( "="):\r
-                raise Warning("expected '='", self.FileName, self.CurrentLineNumber)\r
-            if not self.__IsToken( "{"):\r
-                raise Warning("expected '{'", self.FileName, self.CurrentLineNumber)\r
-            if not self.__SkipToToken( "}"):\r
-                raise Warning("expected Depex expression ending '}'", self.FileName, self.CurrentLineNumber)\r
+            if not self._IsToken(TAB_EQUAL_SPLIT):\r
+                raise Warning.ExpectedEquals(self.FileName, self.CurrentLineNumber)\r
+            if not self._IsToken("{"):\r
+                raise Warning.ExpectedCurlyOpen(self.FileName, self.CurrentLineNumber)\r
+            if not self._SkipToToken(T_CHAR_BRACE_R):\r
+                raise Warning.Expected("Depex expression ending '}'", self.FileName, self.CurrentLineNumber)\r

 \r
 \r

-            DepexSectionObj.Expression = self.__SkippedChars.rstrip('}')\r
+            DepexSectionObj.Expression = self._SkippedChars.rstrip(T_CHAR_BRACE_R)\r

             Obj.SectionList.append(DepexSectionObj)\r
 \r
         else:\r
             Obj.SectionList.append(DepexSectionObj)\r
 \r
         else:\r

-            if not self.__GetNextWord():\r
-                raise Warning("expected section type", self.FileName, self.CurrentLineNumber)\r
+            if not self._GetNextWord():\r
+                raise Warning.Expected("section type", self.FileName, self.CurrentLineNumber)\r

 \r
             # Encapsulation section appear, UndoToken and return\r
 \r
             # Encapsulation section appear, UndoToken and return\r

-            if self.__Token == "COMPRESS" or self.__Token == "GUIDED":\r
+            if self._Token == "COMPRESS" or self._Token == "GUIDED":\r

                 self.SetFileBufferPos(OldPos)\r
                 return False\r
 \r
                 self.SetFileBufferPos(OldPos)\r
                 return False\r
 \r

-            if self.__Token not in ("COMPAT16", "PE32", "PIC", "TE", "FV_IMAGE", "RAW", "DXE_DEPEX",\\r
-                               "UI", "VERSION", "PEI_DEPEX", "SUBTYPE_GUID", "SMM_DEPEX"):\r
-                raise Warning("Unknown section type '%s'" % self.__Token, self.FileName, self.CurrentLineNumber)\r
-            if AlignValue == 'Auto'and (not self.__Token == 'PE32') and (not self.__Token == 'TE'):\r
+            if self._Token not in {"COMPAT16", BINARY_FILE_TYPE_PE32, BINARY_FILE_TYPE_PIC, BINARY_FILE_TYPE_TE, "FV_IMAGE", "RAW", BINARY_FILE_TYPE_DXE_DEPEX,\\r
+                               BINARY_FILE_TYPE_UI, "VERSION", BINARY_FILE_TYPE_PEI_DEPEX, "SUBTYPE_GUID", BINARY_FILE_TYPE_SMM_DEPEX}:\r
+                raise Warning("Unknown section type '%s'" % self._Token, self.FileName, self.CurrentLineNumber)\r
+            if AlignValue == 'Auto'and (not self._Token == BINARY_FILE_TYPE_PE32) and (not self._Token == BINARY_FILE_TYPE_TE):\r

                 raise Warning("Auto alignment can only be used in PE32 or TE section ", self.FileName, self.CurrentLineNumber)\r
 \r
             # DataSection\r
                 raise Warning("Auto alignment can only be used in PE32 or TE section ", self.FileName, self.CurrentLineNumber)\r
 \r
             # DataSection\r

-            DataSectionObj = DataSection.DataSection()\r
+            DataSectionObj = DataSection()\r

             DataSectionObj.Alignment = AlignValue\r
             DataSectionObj.Alignment = AlignValue\r

-            DataSectionObj.SecType = self.__Token\r
+            DataSectionObj.SecType = self._Token\r

 \r
 \r

-            if self.__IsKeyword('RELOCS_STRIPPED') or self.__IsKeyword('RELOCS_RETAINED'):\r
-                if self.__FileCouldHaveRelocFlag(Obj.FvFileType) and self.__SectionCouldHaveRelocFlag(DataSectionObj.SecType):\r
-                    if self.__Token == 'RELOCS_STRIPPED':\r
+            if self._IsKeyword('RELOCS_STRIPPED') or self._IsKeyword('RELOCS_RETAINED'):\r
+                if self._FileCouldHaveRelocFlag(Obj.FvFileType) and self._SectionCouldHaveRelocFlag(DataSectionObj.SecType):\r
+                    if self._Token == 'RELOCS_STRIPPED':\r

                         DataSectionObj.KeepReloc = False\r
                     else:\r
                         DataSectionObj.KeepReloc = True\r
                 else:\r
                     raise Warning("File type %s, section type %s, could not have reloc strip flag%d" % (Obj.FvFileType, DataSectionObj.SecType, self.CurrentLineNumber), self.FileName, self.CurrentLineNumber)\r
 \r
                         DataSectionObj.KeepReloc = False\r
                     else:\r
                         DataSectionObj.KeepReloc = True\r
                 else:\r
                     raise Warning("File type %s, section type %s, could not have reloc strip flag%d" % (Obj.FvFileType, DataSectionObj.SecType, self.CurrentLineNumber), self.FileName, self.CurrentLineNumber)\r
 \r

-            if self.__IsToken("="):\r
-                if not self.__GetNextToken():\r
-                    raise Warning("expected section file path", self.FileName, self.CurrentLineNumber)\r
-                DataSectionObj.SectFileName = self.__Token\r
-                self.__VerifyFile(DataSectionObj.SectFileName)\r
+            if self._IsToken(TAB_EQUAL_SPLIT):\r
+                if not self._GetNextToken():\r
+                    raise Warning.Expected("section file path", self.FileName, self.CurrentLineNumber)\r
+                DataSectionObj.SectFileName = self._Token\r
+                self._VerifyFile(DataSectionObj.SectFileName)\r

             else:\r
             else:\r

-                if not self.__GetCglSection(DataSectionObj):\r
+                if not self._GetCglSection(DataSectionObj):\r

                     return False\r
 \r
             Obj.SectionList.append(DataSectionObj)\r
 \r
         return True\r
 \r
                     return False\r
 \r
             Obj.SectionList.append(DataSectionObj)\r
 \r
         return True\r
 \r

-    ## __VerifyFile\r
+    ## _VerifyFile\r

     #\r
     #    Check if file exists or not:\r
     #      If current phase if GenFds, the file must exist;\r
     #      If current phase is AutoGen and the file is not in $(OUTPUT_DIRECTORY), the file must exist\r
     #    @param FileName: File path to be verified.\r
     #\r
     #\r
     #    Check if file exists or not:\r
     #      If current phase if GenFds, the file must exist;\r
     #      If current phase is AutoGen and the file is not in $(OUTPUT_DIRECTORY), the file must exist\r
     #    @param FileName: File path to be verified.\r
     #\r

-    def __VerifyFile(self, FileName):\r
-        if FileName.replace('$(WORKSPACE)', '').find('$') != -1:\r
+    def _VerifyFile(self, FileName):\r
+        if FileName.replace(TAB_WORKSPACE, '').find('$') != -1:\r

             return\r
             return\r

-        if not GlobalData.gAutoGenPhase or not self.__GetMacroValue("OUTPUT_DIRECTORY") in FileName:\r
+        if not GlobalData.gAutoGenPhase or not self._GetMacroValue(TAB_DSC_DEFINES_OUTPUT_DIRECTORY) in FileName:\r

             ErrorCode, ErrorInfo = PathClass(NormPath(FileName), GenFdsGlobalVariable.WorkSpaceDir).Validate()\r
             if ErrorCode != 0:\r
                 EdkLogger.error("GenFds", ErrorCode, ExtraData=ErrorInfo)\r
 \r
             ErrorCode, ErrorInfo = PathClass(NormPath(FileName), GenFdsGlobalVariable.WorkSpaceDir).Validate()\r
             if ErrorCode != 0:\r
                 EdkLogger.error("GenFds", ErrorCode, ExtraData=ErrorInfo)\r
 \r

-    ## __GetCglSection() method\r
+    ## _GetCglSection() method\r

     #\r
     #   Get compressed or GUIDed section for Obj\r
     #\r
     #\r
     #   Get compressed or GUIDed section for Obj\r
     #\r


@@ -3029,45 +2951,41 @@ class FdfParser:
     #   @retval True        Successfully find section statement\r
     #   @retval False       Not able to find section statement\r
     #\r
     #   @retval True        Successfully find section statement\r
     #   @retval False       Not able to find section statement\r
     #\r

-    def __GetCglSection(self, Obj, AlignValue = None):\r
+    def _GetCglSection(self, Obj, AlignValue = None):\r

 \r
 \r

-        if self.__IsKeyword( "COMPRESS"):\r
+        if self._IsKeyword("COMPRESS"):\r

             type = "PI_STD"\r
             type = "PI_STD"\r

-            if self.__IsKeyword("PI_STD") or self.__IsKeyword("PI_NONE"):\r
-                type = self.__Token\r
+            if self._IsKeyword("PI_STD") or self._IsKeyword("PI_NONE"):\r
+                type = self._Token\r

 \r
 \r

-            if not self.__IsToken("{"):\r
-                raise Warning("expected '{'", self.FileName, self.CurrentLineNumber)\r
+            if not self._IsToken("{"):\r
+                raise Warning.ExpectedCurlyOpen(self.FileName, self.CurrentLineNumber)\r

 \r
 \r

-            CompressSectionObj = CompressSection.CompressSection()\r
+            CompressSectionObj = CompressSection()\r

             CompressSectionObj.Alignment = AlignValue\r
             CompressSectionObj.CompType = type\r
             # Recursive sections...\r
             while True:\r
             CompressSectionObj.Alignment = AlignValue\r
             CompressSectionObj.CompType = type\r
             # Recursive sections...\r
             while True:\r

-                IsLeafSection = self.__GetLeafSection(CompressSectionObj)\r
-                IsEncapSection = self.__GetEncapsulationSec(CompressSectionObj)\r
+                IsLeafSection = self._GetLeafSection(CompressSectionObj)\r
+                IsEncapSection = self._GetEncapsulationSec(CompressSectionObj)\r

                 if not IsLeafSection and not IsEncapSection:\r
                     break\r
 \r
 \r
                 if not IsLeafSection and not IsEncapSection:\r
                     break\r
 \r
 \r

-            if not self.__IsToken( "}"):\r
-                raise Warning("expected '}'", self.FileName, self.CurrentLineNumber)\r
+            if not self._IsToken(T_CHAR_BRACE_R):\r
+                raise Warning.ExpectedCurlyClose(self.FileName, self.CurrentLineNumber)\r

             Obj.SectionList.append(CompressSectionObj)\r
             Obj.SectionList.append(CompressSectionObj)\r

-\r
-#            else:\r
-#               raise Warning("Compress type not known")\r
-\r

             return True\r
 \r
             return True\r
 \r

-        elif self.__IsKeyword( "GUIDED"):\r
+        elif self._IsKeyword("GUIDED"):\r

             GuidValue = None\r
             GuidValue = None\r

-            if self.__GetNextGuid():\r
-                GuidValue = self.__Token\r
+            if self._GetNextGuid():\r
+                GuidValue = self._Token\r

 \r
 \r

-            AttribDict = self.__GetGuidAttrib()\r
-            if not self.__IsToken("{"):\r
-                raise Warning("expected '{'", self.FileName, self.CurrentLineNumber)\r
-            GuidSectionObj = GuidSection.GuidSection()\r
+            AttribDict = self._GetGuidAttrib()\r
+            if not self._IsToken("{"):\r
+                raise Warning.ExpectedCurlyOpen(self.FileName, self.CurrentLineNumber)\r
+            GuidSectionObj = GuidSection()\r

             GuidSectionObj.Alignment = AlignValue\r
             GuidSectionObj.NameGuid = GuidValue\r
             GuidSectionObj.SectionType = "GUIDED"\r
             GuidSectionObj.Alignment = AlignValue\r
             GuidSectionObj.NameGuid = GuidValue\r
             GuidSectionObj.SectionType = "GUIDED"\r


@@ -3076,57 +2994,56 @@ class FdfParser:
             GuidSectionObj.ExtraHeaderSize = AttribDict["EXTRA_HEADER_SIZE"]\r
             # Recursive sections...\r
             while True:\r
             GuidSectionObj.ExtraHeaderSize = AttribDict["EXTRA_HEADER_SIZE"]\r
             # Recursive sections...\r
             while True:\r

-                IsLeafSection = self.__GetLeafSection(GuidSectionObj)\r
-                IsEncapSection = self.__GetEncapsulationSec(GuidSectionObj)\r
+                IsLeafSection = self._GetLeafSection(GuidSectionObj)\r
+                IsEncapSection = self._GetEncapsulationSec(GuidSectionObj)\r

                 if not IsLeafSection and not IsEncapSection:\r
                     break\r
 \r
                 if not IsLeafSection and not IsEncapSection:\r
                     break\r
 \r

-            if not self.__IsToken( "}"):\r
-                raise Warning("expected '}'", self.FileName, self.CurrentLineNumber)\r
+            if not self._IsToken(T_CHAR_BRACE_R):\r
+                raise Warning.ExpectedCurlyClose(self.FileName, self.CurrentLineNumber)\r

             Obj.SectionList.append(GuidSectionObj)\r
 \r
             return True\r
 \r
         return False\r
 \r
             Obj.SectionList.append(GuidSectionObj)\r
 \r
             return True\r
 \r
         return False\r
 \r

-    ## __GetGuidAttri() method\r
+    ## _GetGuidAttri() method\r

     #\r
     #   Get attributes for GUID section\r
     #\r
     #   @param  self        The object pointer\r
     #   @retval AttribDict  Dictionary of key-value pair of section attributes\r
     #\r
     #\r
     #   Get attributes for GUID section\r
     #\r
     #   @param  self        The object pointer\r
     #   @retval AttribDict  Dictionary of key-value pair of section attributes\r
     #\r

-    def __GetGuidAttrib(self):\r
-\r
+    def _GetGuidAttrib(self):\r

         AttribDict = {}\r
         AttribDict["PROCESSING_REQUIRED"] = "NONE"\r
         AttribDict["AUTH_STATUS_VALID"] = "NONE"\r
         AttribDict["EXTRA_HEADER_SIZE"] = -1\r
         AttribDict = {}\r
         AttribDict["PROCESSING_REQUIRED"] = "NONE"\r
         AttribDict["AUTH_STATUS_VALID"] = "NONE"\r
         AttribDict["EXTRA_HEADER_SIZE"] = -1\r

-        while self.__IsKeyword("PROCESSING_REQUIRED") or self.__IsKeyword("AUTH_STATUS_VALID") \\r
-            or self.__IsKeyword("EXTRA_HEADER_SIZE"):\r
-            AttribKey = self.__Token\r
+        while self._IsKeyword("PROCESSING_REQUIRED") or self._IsKeyword("AUTH_STATUS_VALID") \\r
+            or self._IsKeyword("EXTRA_HEADER_SIZE"):\r
+            AttribKey = self._Token\r

 \r
 \r

-            if not self.__IsToken("="):\r
-                raise Warning("expected '='", self.FileName, self.CurrentLineNumber)\r
+            if not self._IsToken(TAB_EQUAL_SPLIT):\r
+                raise Warning.ExpectedEquals(self.FileName, self.CurrentLineNumber)\r

 \r
 \r

-            if not self.__GetNextToken():\r
-                raise Warning("expected TRUE(1)/FALSE(0)/Number", self.FileName, self.CurrentLineNumber)\r
+            if not self._GetNextToken():\r
+                raise Warning.Expected("TRUE(1)/FALSE(0)/Number", self.FileName, self.CurrentLineNumber)\r

             elif AttribKey == "EXTRA_HEADER_SIZE":\r
                 Base = 10\r
             elif AttribKey == "EXTRA_HEADER_SIZE":\r
                 Base = 10\r

-                if self.__Token[0:2].upper() == "0X":\r
+                if self._Token[0:2].upper() == "0X":\r

                     Base = 16\r
                 try:\r
                     Base = 16\r
                 try:\r

-                    AttribDict[AttribKey] = int(self.__Token, Base)\r
+                    AttribDict[AttribKey] = int(self._Token, Base)\r

                     continue\r
                 except ValueError:\r
                     continue\r
                 except ValueError:\r

-                    raise Warning("expected Number", self.FileName, self.CurrentLineNumber)\r
-            elif self.__Token.upper() not in ("TRUE", "FALSE", "1", "0"):\r
-                raise Warning("expected TRUE/FALSE (1/0)", self.FileName, self.CurrentLineNumber)\r
-            AttribDict[AttribKey] = self.__Token\r
+                    raise Warning.Expected("Number", self.FileName, self.CurrentLineNumber)\r
+            elif self._Token.upper() not in {"TRUE", "FALSE", "1", "0"}:\r
+                raise Warning.Expected("TRUE/FALSE (1/0)", self.FileName, self.CurrentLineNumber)\r
+            AttribDict[AttribKey] = self._Token\r

 \r
         return AttribDict\r
 \r
 \r
         return AttribDict\r
 \r

-    ## __GetEncapsulationSec() method\r
+    ## _GetEncapsulationSec() method\r

     #\r
     #   Get encapsulation section for FILE\r
     #\r
     #\r
     #   Get encapsulation section for FILE\r
     #\r


@@ -3135,109 +3052,107 @@ class FdfParser:
     #   @retval True        Successfully find section statement\r
     #   @retval False       Not able to find section statement\r
     #\r
     #   @retval True        Successfully find section statement\r
     #   @retval False       Not able to find section statement\r
     #\r

-    def __GetEncapsulationSec(self, FfsFileObj):\r
-\r
+    def _GetEncapsulationSec(self, FfsFileObj):\r

         OldPos = self.GetFileBufferPos()\r
         OldPos = self.GetFileBufferPos()\r

-        if not self.__IsKeyword( "SECTION"):\r
+        if not self._IsKeyword("SECTION"):\r

             if len(FfsFileObj.SectionList) == 0:\r
             if len(FfsFileObj.SectionList) == 0:\r

-                raise Warning("expected SECTION", self.FileName, self.CurrentLineNumber)\r
+                raise Warning.Expected("SECTION", self.FileName, self.CurrentLineNumber)\r

             else:\r
                 return False\r
 \r
         AlignValue = None\r
             else:\r
                 return False\r
 \r
         AlignValue = None\r

-        if self.__GetAlignment():\r
-            if self.__Token not in ("8", "16", "32", "64", "128", "512", "1K", "4K", "32K" ,"64K", "128K",\r
-                                    "256K", "512K", "1M", "2M", "4M", "8M", "16M"):\r
-                raise Warning("Incorrect alignment '%s'" % self.__Token, self.FileName, self.CurrentLineNumber)\r
-            AlignValue = self.__Token\r
+        if self._GetAlignment():\r
+            if self._Token not in ALIGNMENT_NOAUTO:\r
+                raise Warning("Incorrect alignment '%s'" % self._Token, self.FileName, self.CurrentLineNumber)\r
+            AlignValue = self._Token\r

 \r
 \r

-        if not self.__GetCglSection(FfsFileObj, AlignValue):\r
+        if not self._GetCglSection(FfsFileObj, AlignValue):\r

             self.SetFileBufferPos(OldPos)\r
             return False\r
         else:\r
             return True\r
 \r
             self.SetFileBufferPos(OldPos)\r
             return False\r
         else:\r
             return True\r
 \r

-    def __GetFmp(self):\r
-        if not self.__GetNextToken():\r
+    def _GetFmp(self):\r
+        if not self._GetNextToken():\r

             return False\r
             return False\r

-        S = self.__Token.upper()\r
-        if S.startswith("[") and not S.startswith("[FMPPAYLOAD."):\r
+        S = self._Token.upper()\r
+        if S.startswith(TAB_SECTION_START) and not S.startswith("[FMPPAYLOAD."):\r

             self.SectionParser(S)\r
             self.SectionParser(S)\r

-            self.__UndoToken()\r
+            self._UndoToken()\r

             return False\r
 \r
             return False\r
 \r

-        self.__UndoToken()\r
-        self.__SkipToToken("[FMPPAYLOAD.", True)\r
-        FmpUiName = self.__GetUiName().upper()\r
+        self._UndoToken()\r
+        self._SkipToToken("[FMPPAYLOAD.", True)\r
+        FmpUiName = self._GetUiName().upper()\r

         if FmpUiName in self.Profile.FmpPayloadDict:\r
             raise Warning("Duplicated FMP UI name found: %s" % FmpUiName, self.FileName, self.CurrentLineNumber)\r
 \r
         if FmpUiName in self.Profile.FmpPayloadDict:\r
             raise Warning("Duplicated FMP UI name found: %s" % FmpUiName, self.FileName, self.CurrentLineNumber)\r
 \r

-        FmpData = CapsuleData.CapsulePayload()\r
+        FmpData = CapsulePayload()\r

         FmpData.UiName = FmpUiName\r
 \r
         FmpData.UiName = FmpUiName\r
 \r

-        if not self.__IsToken( "]"):\r
-            raise Warning("expected ']'", self.FileName, self.CurrentLineNumber)\r
+        if not self._IsToken(TAB_SECTION_END):\r
+            raise Warning.ExpectedBracketClose(self.FileName, self.CurrentLineNumber)\r

 \r
 \r

-        if not self.__GetNextToken():\r
+        if not self._GetNextToken():\r

             raise Warning("The FMP payload section is empty!", self.FileName, self.CurrentLineNumber)\r
         FmpKeyList = ['IMAGE_HEADER_INIT_VERSION', 'IMAGE_TYPE_ID', 'IMAGE_INDEX', 'HARDWARE_INSTANCE', 'CERTIFICATE_GUID', 'MONOTONIC_COUNT']\r
             raise Warning("The FMP payload section is empty!", self.FileName, self.CurrentLineNumber)\r
         FmpKeyList = ['IMAGE_HEADER_INIT_VERSION', 'IMAGE_TYPE_ID', 'IMAGE_INDEX', 'HARDWARE_INSTANCE', 'CERTIFICATE_GUID', 'MONOTONIC_COUNT']\r

-        while self.__Token in FmpKeyList:\r
-            Name = self.__Token\r
+        while self._Token in FmpKeyList:\r
+            Name = self._Token\r

             FmpKeyList.remove(Name)\r
             FmpKeyList.remove(Name)\r

-            if not self.__IsToken("="):\r
-                raise Warning("expected '='", self.FileName, self.CurrentLineNumber)\r
+            if not self._IsToken(TAB_EQUAL_SPLIT):\r
+                raise Warning.ExpectedEquals(self.FileName, self.CurrentLineNumber)\r

             if Name == 'IMAGE_TYPE_ID':\r
             if Name == 'IMAGE_TYPE_ID':\r

-                if not self.__GetNextGuid():\r
-                    raise Warning("expected GUID value for IMAGE_TYPE_ID.", self.FileName, self.CurrentLineNumber)\r
-                FmpData.ImageTypeId = self.__Token\r
+                if not self._GetNextGuid():\r
+                    raise Warning.Expected("GUID value for IMAGE_TYPE_ID.", self.FileName, self.CurrentLineNumber)\r
+                FmpData.ImageTypeId = self._Token\r

             elif Name == 'CERTIFICATE_GUID':\r
             elif Name == 'CERTIFICATE_GUID':\r

-                if not self.__GetNextGuid():\r
-                    raise Warning("expected GUID value for CERTIFICATE_GUID.", self.FileName, self.CurrentLineNumber)\r
-                FmpData.Certificate_Guid = self.__Token\r
-                if uuid.UUID(FmpData.Certificate_Guid) != EFI_CERT_TYPE_RSA2048_SHA256_GUID and uuid.UUID(FmpData.Certificate_Guid) != EFI_CERT_TYPE_PKCS7_GUID:\r
+                if not self._GetNextGuid():\r
+                    raise Warning.Expected("GUID value for CERTIFICATE_GUID.", self.FileName, self.CurrentLineNumber)\r
+                FmpData.Certificate_Guid = self._Token\r
+                if UUID(FmpData.Certificate_Guid) != EFI_CERT_TYPE_RSA2048_SHA256_GUID and UUID(FmpData.Certificate_Guid) != EFI_CERT_TYPE_PKCS7_GUID:\r

                     raise Warning("Only support EFI_CERT_TYPE_RSA2048_SHA256_GUID or EFI_CERT_TYPE_PKCS7_GUID for CERTIFICATE_GUID.", self.FileName, self.CurrentLineNumber)\r
             else:\r
                     raise Warning("Only support EFI_CERT_TYPE_RSA2048_SHA256_GUID or EFI_CERT_TYPE_PKCS7_GUID for CERTIFICATE_GUID.", self.FileName, self.CurrentLineNumber)\r
             else:\r

-                if not self.__GetNextToken():\r
-                    raise Warning("expected value of %s" % Name, self.FileName, self.CurrentLineNumber)\r
-                Value = self.__Token\r
+                if not self._GetNextToken():\r
+                    raise Warning.Expected("value of %s" % Name, self.FileName, self.CurrentLineNumber)\r
+                Value = self._Token\r

                 if Name == 'IMAGE_HEADER_INIT_VERSION':\r
                 if Name == 'IMAGE_HEADER_INIT_VERSION':\r

-                    if self.__Verify(Name, Value, 'UINT8'):\r
+                    if FdfParser._Verify(Name, Value, 'UINT8'):\r

                         FmpData.Version = Value\r
                 elif Name == 'IMAGE_INDEX':\r
                         FmpData.Version = Value\r
                 elif Name == 'IMAGE_INDEX':\r

-                    if self.__Verify(Name, Value, 'UINT8'):\r
+                    if FdfParser._Verify(Name, Value, 'UINT8'):\r

                         FmpData.ImageIndex = Value\r
                 elif Name == 'HARDWARE_INSTANCE':\r
                         FmpData.ImageIndex = Value\r
                 elif Name == 'HARDWARE_INSTANCE':\r

-                    if self.__Verify(Name, Value, 'UINT8'):\r
+                    if FdfParser._Verify(Name, Value, 'UINT8'):\r

                         FmpData.HardwareInstance = Value\r
                 elif Name == 'MONOTONIC_COUNT':\r
                         FmpData.HardwareInstance = Value\r
                 elif Name == 'MONOTONIC_COUNT':\r

-                    if self.__Verify(Name, Value, 'UINT64'):\r
+                    if FdfParser._Verify(Name, Value, 'UINT64'):\r

                         FmpData.MonotonicCount = Value\r
                         if FmpData.MonotonicCount.upper().startswith('0X'):\r
                         FmpData.MonotonicCount = Value\r
                         if FmpData.MonotonicCount.upper().startswith('0X'):\r

-                            FmpData.MonotonicCount = (long)(FmpData.MonotonicCount, 16)\r
+                            FmpData.MonotonicCount = int(FmpData.MonotonicCount, 16)\r

                         else:\r
                         else:\r

-                            FmpData.MonotonicCount = (long)(FmpData.MonotonicCount)\r
-            if not self.__GetNextToken():\r
+                            FmpData.MonotonicCount = int(FmpData.MonotonicCount)\r
+            if not self._GetNextToken():\r

                 break\r
         else:\r
                 break\r
         else:\r

-            self.__UndoToken()\r
+            self._UndoToken()\r

 \r
         if (FmpData.MonotonicCount and not FmpData.Certificate_Guid) or (not FmpData.MonotonicCount and FmpData.Certificate_Guid):\r
             EdkLogger.error("FdfParser", FORMAT_INVALID, "CERTIFICATE_GUID and MONOTONIC_COUNT must be work as a pair.")\r
 \r
         # Only the IMAGE_TYPE_ID is required item\r
         if FmpKeyList and 'IMAGE_TYPE_ID' in FmpKeyList:\r
 \r
         if (FmpData.MonotonicCount and not FmpData.Certificate_Guid) or (not FmpData.MonotonicCount and FmpData.Certificate_Guid):\r
             EdkLogger.error("FdfParser", FORMAT_INVALID, "CERTIFICATE_GUID and MONOTONIC_COUNT must be work as a pair.")\r
 \r
         # Only the IMAGE_TYPE_ID is required item\r
         if FmpKeyList and 'IMAGE_TYPE_ID' in FmpKeyList:\r

-            raise Warning("Missing keywords IMAGE_TYPE_ID in FMP payload section.", self.FileName, self.CurrentLineNumber)\r
+            raise Warning("'IMAGE_TYPE_ID' in FMP payload section.", self.FileName, self.CurrentLineNumber)\r

         # get the Image file and Vendor code file\r
         # get the Image file and Vendor code file\r

-        self.__GetFMPCapsuleData(FmpData)\r
+        self._GetFMPCapsuleData(FmpData)\r

         if not FmpData.ImageFile:\r
             raise Warning("Missing image file in FMP payload section.", self.FileName, self.CurrentLineNumber)\r
         # check whether more than one Vendor code file\r
         if len(FmpData.VendorCodeFile) > 1:\r
         if not FmpData.ImageFile:\r
             raise Warning("Missing image file in FMP payload section.", self.FileName, self.CurrentLineNumber)\r
         # check whether more than one Vendor code file\r
         if len(FmpData.VendorCodeFile) > 1:\r

-            raise Warning("At most one Image file and one Vendor code file are allowed in FMP payload section.", self.FileName, self.CurrentLineNumber)\r
+            raise Warning("Vendor code file max of 1 per FMP payload section.", self.FileName, self.CurrentLineNumber)\r

         self.Profile.FmpPayloadDict[FmpUiName] = FmpData\r
         return True\r
 \r
         self.Profile.FmpPayloadDict[FmpUiName] = FmpData\r
         return True\r
 \r

-    ## __GetCapsule() method\r
+    ## _GetCapsule() method\r

     #\r
     #   Get capsule section contents and store its data into capsule list of self.Profile\r
     #\r
     #\r
     #   Get capsule section contents and store its data into capsule list of self.Profile\r
     #\r


@@ -3245,143 +3160,140 @@ class FdfParser:
     #   @retval True        Successfully find a capsule\r
     #   @retval False       Not able to find a capsule\r
     #\r
     #   @retval True        Successfully find a capsule\r
     #   @retval False       Not able to find a capsule\r
     #\r

-    def __GetCapsule(self):\r
-\r
-        if not self.__GetNextToken():\r
+    def _GetCapsule(self):\r
+        if not self._GetNextToken():\r

             return False\r
 \r
             return False\r
 \r

-        S = self.__Token.upper()\r
-        if S.startswith("[") and not S.startswith("[CAPSULE."):\r
+        S = self._Token.upper()\r
+        if S.startswith(TAB_SECTION_START) and not S.startswith("[CAPSULE."):\r

             self.SectionParser(S)\r
             self.SectionParser(S)\r

-            self.__UndoToken()\r
+            self._UndoToken()\r

             return False\r
 \r
             return False\r
 \r

-        self.__UndoToken()\r
-        if not self.__IsToken("[CAPSULE.", True):\r
+        self._UndoToken()\r
+        if not self._IsToken("[CAPSULE.", True):\r

             FileLineTuple = GetRealFileLine(self.FileName, self.CurrentLineNumber)\r
             #print 'Parsing String: %s in File %s, At line: %d, Offset Within Line: %d' \\r
             FileLineTuple = GetRealFileLine(self.FileName, self.CurrentLineNumber)\r
             #print 'Parsing String: %s in File %s, At line: %d, Offset Within Line: %d' \\r

-            #        % (self.Profile.FileLinesList[self.CurrentLineNumber - 1][self.CurrentOffsetWithinLine :], FileLineTuple[0], FileLineTuple[1], self.CurrentOffsetWithinLine)\r
-            raise Warning("expected [Capsule.]", self.FileName, self.CurrentLineNumber)\r
+            #        % (self.Profile.FileLinesList[self.CurrentLineNumber - 1][self.CurrentOffsetWithinLine:], FileLineTuple[0], FileLineTuple[1], self.CurrentOffsetWithinLine)\r
+            raise Warning.Expected("[Capsule.]", self.FileName, self.CurrentLineNumber)\r

 \r
 \r

-        CapsuleObj = Capsule.Capsule()\r
+        CapsuleObj = Capsule()\r

 \r
 \r

-        CapsuleName = self.__GetUiName()\r
+        CapsuleName = self._GetUiName()\r

         if not CapsuleName:\r
         if not CapsuleName:\r

-            raise Warning("expected capsule name", self.FileName, self.CurrentLineNumber)\r
+            raise Warning.Expected("capsule name", self.FileName, self.CurrentLineNumber)\r

 \r
         CapsuleObj.UiCapsuleName = CapsuleName.upper()\r
 \r
 \r
         CapsuleObj.UiCapsuleName = CapsuleName.upper()\r
 \r

-        if not self.__IsToken( "]"):\r
-            raise Warning("expected ']'", self.FileName, self.CurrentLineNumber)\r
+        if not self._IsToken(TAB_SECTION_END):\r
+            raise Warning.ExpectedBracketClose(self.FileName, self.CurrentLineNumber)\r

 \r
 \r

-        if self.__IsKeyword("CREATE_FILE"):\r
-            if not self.__IsToken( "="):\r
-                raise Warning("expected '='", self.FileName, self.CurrentLineNumber)\r
+        if self._IsKeyword("CREATE_FILE"):\r
+            if not self._IsToken(TAB_EQUAL_SPLIT):\r
+                raise Warning.ExpectedEquals(self.FileName, self.CurrentLineNumber)\r

 \r
 \r

-            if not self.__GetNextToken():\r
-                raise Warning("expected file name", self.FileName, self.CurrentLineNumber)\r
+            if not self._GetNextToken():\r
+                raise Warning.Expected("file name", self.FileName, self.CurrentLineNumber)\r

 \r
 \r

-            CapsuleObj.CreateFile = self.__Token\r
+            CapsuleObj.CreateFile = self._Token\r

 \r
 \r

-        self.__GetCapsuleStatements(CapsuleObj)\r
+        self._GetCapsuleStatements(CapsuleObj)\r

         self.Profile.CapsuleDict[CapsuleObj.UiCapsuleName] = CapsuleObj\r
         return True\r
 \r
         self.Profile.CapsuleDict[CapsuleObj.UiCapsuleName] = CapsuleObj\r
         return True\r
 \r

-    ## __GetCapsuleStatements() method\r
+    ## _GetCapsuleStatements() method\r

     #\r
     #   Get statements for capsule\r
     #\r
     #   @param  self        The object pointer\r
     #   @param  Obj         for whom statements are got\r
     #\r
     #\r
     #   Get statements for capsule\r
     #\r
     #   @param  self        The object pointer\r
     #   @param  Obj         for whom statements are got\r
     #\r

-    def __GetCapsuleStatements(self, Obj):\r
-        self.__GetCapsuleTokens(Obj)\r
-        self.__GetDefineStatements(Obj)\r
-        self.__GetSetStatements(Obj)\r
-        self.__GetCapsuleData(Obj)\r
+    def _GetCapsuleStatements(self, Obj):\r
+        self._GetCapsuleTokens(Obj)\r
+        self._GetDefineStatements(Obj)\r
+        self._GetSetStatements(Obj)\r
+        self._GetCapsuleData(Obj)\r

 \r
 \r

-    ## __GetCapsuleTokens() method\r
+    ## _GetCapsuleTokens() method\r

     #\r
     #   Get token statements for capsule\r
     #\r
     #   @param  self        The object pointer\r
     #   @param  Obj         for whom token statements are got\r
     #\r
     #\r
     #   Get token statements for capsule\r
     #\r
     #   @param  self        The object pointer\r
     #   @param  Obj         for whom token statements are got\r
     #\r

-    def __GetCapsuleTokens(self, Obj):\r
-        if not self.__GetNextToken():\r
+    def _GetCapsuleTokens(self, Obj):\r
+        if not self._GetNextToken():\r

             return False\r
             return False\r

-        while self.__Token in ("CAPSULE_GUID", "CAPSULE_HEADER_SIZE", "CAPSULE_FLAGS", "OEM_CAPSULE_FLAGS", "CAPSULE_HEADER_INIT_VERSION"):\r
-            Name = self.__Token.strip()\r
-            if not self.__IsToken("="):\r
-                raise Warning("expected '='", self.FileName, self.CurrentLineNumber)\r
-            if not self.__GetNextToken():\r
-                raise Warning("expected value", self.FileName, self.CurrentLineNumber)\r
+        while self._Token in {"CAPSULE_GUID", "CAPSULE_HEADER_SIZE", "CAPSULE_FLAGS", "OEM_CAPSULE_FLAGS", "CAPSULE_HEADER_INIT_VERSION"}:\r
+            Name = self._Token.strip()\r
+            if not self._IsToken(TAB_EQUAL_SPLIT):\r
+                raise Warning.ExpectedEquals(self.FileName, self.CurrentLineNumber)\r
+            if not self._GetNextToken():\r
+                raise Warning.Expected("value", self.FileName, self.CurrentLineNumber)\r

             if Name == 'CAPSULE_FLAGS':\r
             if Name == 'CAPSULE_FLAGS':\r

-                if not self.__Token in ("PersistAcrossReset", "PopulateSystemTable", "InitiateReset"):\r
-                    raise Warning("expected PersistAcrossReset, PopulateSystemTable, or InitiateReset", self.FileName, self.CurrentLineNumber)\r
-                Value = self.__Token.strip()\r
-                while self.__IsToken(","):\r
-                    Value += ','\r
-                    if not self.__GetNextToken():\r
-                        raise Warning("expected value", self.FileName, self.CurrentLineNumber)\r
-                    if not self.__Token in ("PersistAcrossReset", "PopulateSystemTable", "InitiateReset"):\r
-                        raise Warning("expected PersistAcrossReset, PopulateSystemTable, or InitiateReset", self.FileName, self.CurrentLineNumber)\r
-                    Value += self.__Token.strip()\r
+                if not self._Token in {"PersistAcrossReset", "PopulateSystemTable", "InitiateReset"}:\r
+                    raise Warning.Expected("PersistAcrossReset, PopulateSystemTable, or InitiateReset", self.FileName, self.CurrentLineNumber)\r
+                Value = self._Token.strip()\r
+                while self._IsToken(TAB_COMMA_SPLIT):\r
+                    Value += TAB_COMMA_SPLIT\r
+                    if not self._GetNextToken():\r
+                        raise Warning.Expected("value", self.FileName, self.CurrentLineNumber)\r
+                    if not self._Token in {"PersistAcrossReset", "PopulateSystemTable", "InitiateReset"}:\r
+                        raise Warning.Expected("PersistAcrossReset, PopulateSystemTable, or InitiateReset", self.FileName, self.CurrentLineNumber)\r
+                    Value += self._Token.strip()\r

             elif Name == 'OEM_CAPSULE_FLAGS':\r
             elif Name == 'OEM_CAPSULE_FLAGS':\r

-                Value = self.__Token.strip()\r
+                Value = self._Token.strip()\r

                 if not Value.upper().startswith('0X'):\r
                 if not Value.upper().startswith('0X'):\r

-                    raise Warning("expected hex value between 0x0000 and 0xFFFF", self.FileName, self.CurrentLineNumber)\r
+                    raise Warning.Expected("hex value starting with 0x", self.FileName, self.CurrentLineNumber)\r

                 try:\r
                     Value = int(Value, 0)\r
                 except ValueError:\r
                 try:\r
                     Value = int(Value, 0)\r
                 except ValueError:\r

-                    raise Warning("expected hex value between 0x0000 and 0xFFFF", self.FileName, self.CurrentLineNumber)\r
+                    raise Warning.Expected("hex string failed to convert to value", self.FileName, self.CurrentLineNumber)\r

                 if not 0x0000 <= Value <= 0xFFFF:\r
                 if not 0x0000 <= Value <= 0xFFFF:\r

-                    raise Warning("expected hex value between 0x0000 and 0xFFFF", self.FileName, self.CurrentLineNumber)\r
-                Value = self.__Token.strip()\r
+                    raise Warning.Expected("hex value between 0x0000 and 0xFFFF", self.FileName, self.CurrentLineNumber)\r
+                Value = self._Token.strip()\r

             else:\r
             else:\r

-                Value = self.__Token.strip()\r
-            Obj.TokensDict[Name] = Value  \r
-            if not self.__GetNextToken():\r
+                Value = self._Token.strip()\r
+            Obj.TokensDict[Name] = Value\r
+            if not self._GetNextToken():\r

                 return False\r
                 return False\r

-        self.__UndoToken()\r
+        self._UndoToken()\r

 \r
 \r

-    ## __GetCapsuleData() method\r
+    ## _GetCapsuleData() method\r

     #\r
     #   Get capsule data for capsule\r
     #\r
     #   @param  self        The object pointer\r
     #   @param  Obj         for whom capsule data are got\r
     #\r
     #\r
     #   Get capsule data for capsule\r
     #\r
     #   @param  self        The object pointer\r
     #   @param  Obj         for whom capsule data are got\r
     #\r

-    def __GetCapsuleData(self, Obj):\r
-\r
+    def _GetCapsuleData(self, Obj):\r

         while True:\r
         while True:\r

-            IsInf = self.__GetInfStatement(Obj, True)\r
-            IsFile = self.__GetFileStatement(Obj, True)\r
-            IsFv = self.__GetFvStatement(Obj)\r
-            IsFd = self.__GetFdStatement(Obj)\r
-            IsAnyFile = self.__GetAnyFileStatement(Obj)\r
-            IsAfile = self.__GetAfileStatement(Obj)\r
-            IsFmp = self.__GetFmpStatement(Obj)\r
+            IsInf = self._GetInfStatement(Obj, True)\r
+            IsFile = self._GetFileStatement(Obj, True)\r
+            IsFv = self._GetFvStatement(Obj)\r
+            IsFd = self._GetFdStatement(Obj)\r
+            IsAnyFile = self._GetAnyFileStatement(Obj)\r
+            IsAfile = self._GetAfileStatement(Obj)\r
+            IsFmp = self._GetFmpStatement(Obj)\r

             if not (IsInf or IsFile or IsFv or IsFd or IsAnyFile or IsAfile or IsFmp):\r
                 break\r
 \r
             if not (IsInf or IsFile or IsFv or IsFd or IsAnyFile or IsAfile or IsFmp):\r
                 break\r
 \r

-    ## __GetFMPCapsuleData() method\r
+    ## _GetFMPCapsuleData() method\r

     #\r
     #   Get capsule data for FMP capsule\r
     #\r
     #   @param  self        The object pointer\r
     #   @param  Obj         for whom capsule data are got\r
     #\r
     #\r
     #   Get capsule data for FMP capsule\r
     #\r
     #   @param  self        The object pointer\r
     #   @param  Obj         for whom capsule data are got\r
     #\r

-    def __GetFMPCapsuleData(self, Obj):\r
-\r
+    def _GetFMPCapsuleData(self, Obj):\r

         while True:\r
         while True:\r

-            IsFv = self.__GetFvStatement(Obj, True)\r
-            IsFd = self.__GetFdStatement(Obj, True)\r
-            IsAnyFile = self.__GetAnyFileStatement(Obj, True)\r
+            IsFv = self._GetFvStatement(Obj, True)\r
+            IsFd = self._GetFdStatement(Obj, True)\r
+            IsAnyFile = self._GetAnyFileStatement(Obj, True)\r

             if not (IsFv or IsFd or IsAnyFile):\r
                 break\r
 \r
             if not (IsFv or IsFd or IsAnyFile):\r
                 break\r
 \r

-    ## __GetFvStatement() method\r
+    ## _GetFvStatement() method\r

     #\r
     #   Get FV for capsule\r
     #\r
     #\r
     #   Get FV for capsule\r
     #\r


@@ -3390,32 +3302,31 @@ class FdfParser:
     #   @retval True        Successfully find a FV statement\r
     #   @retval False       Not able to find a FV statement\r
     #\r
     #   @retval True        Successfully find a FV statement\r
     #   @retval False       Not able to find a FV statement\r
     #\r

-    def __GetFvStatement(self, CapsuleObj, FMPCapsule = False):\r
-\r
-        if not self.__IsKeyword("FV"):\r
+    def _GetFvStatement(self, CapsuleObj, FMPCapsule = False):\r
+        if not self._IsKeyword(BINARY_FILE_TYPE_FV):\r

             return False\r
 \r
             return False\r
 \r

-        if not self.__IsToken("="):\r
-            raise Warning("expected '='", self.FileName, self.CurrentLineNumber)\r
+        if not self._IsToken(TAB_EQUAL_SPLIT):\r
+            raise Warning.ExpectedEquals(self.FileName, self.CurrentLineNumber)\r

 \r
 \r

-        if not self.__GetNextToken():\r
-            raise Warning("expected FV name", self.FileName, self.CurrentLineNumber)\r
+        if not self._GetNextToken():\r
+            raise Warning.Expected("FV name", self.FileName, self.CurrentLineNumber)\r

 \r
 \r

-        if self.__Token.upper() not in self.Profile.FvDict.keys():\r
+        if self._Token.upper() not in self.Profile.FvDict:\r

             raise Warning("FV name does not exist", self.FileName, self.CurrentLineNumber)\r
 \r
             raise Warning("FV name does not exist", self.FileName, self.CurrentLineNumber)\r
 \r

-        CapsuleFv = CapsuleData.CapsuleFv()\r
-        CapsuleFv.FvName = self.__Token\r
+        myCapsuleFv = CapsuleFv()\r
+        myCapsuleFv.FvName = self._Token\r

         if FMPCapsule:\r
             if not CapsuleObj.ImageFile:\r
         if FMPCapsule:\r
             if not CapsuleObj.ImageFile:\r

-                CapsuleObj.ImageFile.append(CapsuleFv)\r
+                CapsuleObj.ImageFile.append(myCapsuleFv)\r

             else:\r
             else:\r

-                CapsuleObj.VendorCodeFile.append(CapsuleFv)\r
+                CapsuleObj.VendorCodeFile.append(myCapsuleFv)\r

         else:\r
         else:\r

-            CapsuleObj.CapsuleDataList.append(CapsuleFv)\r
+            CapsuleObj.CapsuleDataList.append(myCapsuleFv)\r

         return True\r
 \r
         return True\r
 \r

-    ## __GetFdStatement() method\r
+    ## _GetFdStatement() method\r

     #\r
     #   Get FD for capsule\r
     #\r
     #\r
     #   Get FD for capsule\r
     #\r


@@ -3424,74 +3335,73 @@ class FdfParser:
     #   @retval True        Successfully find a FD statement\r
     #   @retval False       Not able to find a FD statement\r
     #\r
     #   @retval True        Successfully find a FD statement\r
     #   @retval False       Not able to find a FD statement\r
     #\r

-    def __GetFdStatement(self, CapsuleObj, FMPCapsule = False):\r
-\r
-        if not self.__IsKeyword("FD"):\r
+    def _GetFdStatement(self, CapsuleObj, FMPCapsule = False):\r
+        if not self._IsKeyword("FD"):\r

             return False\r
 \r
             return False\r
 \r

-        if not self.__IsToken("="):\r
-            raise Warning("expected '='", self.FileName, self.CurrentLineNumber)\r
+        if not self._IsToken(TAB_EQUAL_SPLIT):\r
+            raise Warning.ExpectedEquals(self.FileName, self.CurrentLineNumber)\r

 \r
 \r

-        if not self.__GetNextToken():\r
-            raise Warning("expected FD name", self.FileName, self.CurrentLineNumber)\r
+        if not self._GetNextToken():\r
+            raise Warning.Expected("FD name", self.FileName, self.CurrentLineNumber)\r

 \r
 \r

-        if self.__Token.upper() not in self.Profile.FdDict.keys():\r
+        if self._Token.upper() not in self.Profile.FdDict:\r

             raise Warning("FD name does not exist", self.FileName, self.CurrentLineNumber)\r
 \r
             raise Warning("FD name does not exist", self.FileName, self.CurrentLineNumber)\r
 \r

-        CapsuleFd = CapsuleData.CapsuleFd()\r
-        CapsuleFd.FdName = self.__Token\r
+        myCapsuleFd = CapsuleFd()\r
+        myCapsuleFd.FdName = self._Token\r

         if FMPCapsule:\r
             if not CapsuleObj.ImageFile:\r
         if FMPCapsule:\r
             if not CapsuleObj.ImageFile:\r

-                CapsuleObj.ImageFile.append(CapsuleFd)\r
+                CapsuleObj.ImageFile.append(myCapsuleFd)\r

             else:\r
             else:\r

-                CapsuleObj.VendorCodeFile.append(CapsuleFd)\r
+                CapsuleObj.VendorCodeFile.append(myCapsuleFd)\r

         else:\r
         else:\r

-            CapsuleObj.CapsuleDataList.append(CapsuleFd)\r
+            CapsuleObj.CapsuleDataList.append(myCapsuleFd)\r

         return True\r
 \r
         return True\r
 \r

-    def __GetFmpStatement(self, CapsuleObj):\r
-        if not self.__IsKeyword("FMP_PAYLOAD"):\r
-            if not self.__IsKeyword("FMP"):\r
+    def _GetFmpStatement(self, CapsuleObj):\r
+        if not self._IsKeyword("FMP_PAYLOAD"):\r
+            if not self._IsKeyword("FMP"):\r

                 return False\r
 \r
                 return False\r
 \r

-            if not self.__IsKeyword("PAYLOAD"):\r
-                self.__UndoToken()\r
+            if not self._IsKeyword("PAYLOAD"):\r
+                self._UndoToken()\r

                 return False\r
 \r
                 return False\r
 \r

-        if not self.__IsToken("="):\r
-            raise Warning("expected '='", self.FileName, self.CurrentLineNumber)\r
+        if not self._IsToken(TAB_EQUAL_SPLIT):\r
+            raise Warning.ExpectedEquals(self.FileName, self.CurrentLineNumber)\r

 \r
 \r

-        if not self.__GetNextToken():\r
-            raise Warning("expected payload name after FMP_PAYLOAD =", self.FileName, self.CurrentLineNumber)\r
-        Payload = self.__Token.upper()\r
+        if not self._GetNextToken():\r
+            raise Warning.Expected("payload name after FMP_PAYLOAD =", self.FileName, self.CurrentLineNumber)\r
+        Payload = self._Token.upper()\r

         if Payload not in self.Profile.FmpPayloadDict:\r
         if Payload not in self.Profile.FmpPayloadDict:\r

-            raise Warning("This FMP Payload does not exist: %s" % self.__Token, self.FileName, self.CurrentLineNumber)\r
+            raise Warning("This FMP Payload does not exist: %s" % self._Token, self.FileName, self.CurrentLineNumber)\r

         CapsuleObj.FmpPayloadList.append(self.Profile.FmpPayloadDict[Payload])\r
         return True\r
 \r
         CapsuleObj.FmpPayloadList.append(self.Profile.FmpPayloadDict[Payload])\r
         return True\r
 \r

-    def __ParseRawFileStatement(self):\r
-        if not self.__IsKeyword("FILE"):\r
+    def _ParseRawFileStatement(self):\r
+        if not self._IsKeyword("FILE"):\r

             return None\r
 \r
             return None\r
 \r

-        if not self.__IsKeyword("DATA"):\r
-            self.__UndoToken()\r
+        if not self._IsKeyword("DATA"):\r
+            self._UndoToken()\r

             return None\r
 \r
             return None\r
 \r

-        if not self.__IsToken("="):\r
-            raise Warning("expected '='", self.FileName, self.CurrentLineNumber)\r
+        if not self._IsToken(TAB_EQUAL_SPLIT):\r
+            raise Warning.ExpectedEquals(self.FileName, self.CurrentLineNumber)\r

 \r
 \r

-        if not self.__GetNextToken():\r
-            raise Warning("expected File name", self.FileName, self.CurrentLineNumber)\r
-        \r
-        AnyFileName = self.__Token\r
-        self.__VerifyFile(AnyFileName)\r
+        if not self._GetNextToken():\r
+            raise Warning.Expected("File name", self.FileName, self.CurrentLineNumber)\r
+\r
+        AnyFileName = self._Token\r
+        self._VerifyFile(AnyFileName)\r

 \r
         if not os.path.isabs(AnyFileName):\r
             AnyFileName = mws.join(GenFdsGlobalVariable.WorkSpaceDir, AnyFileName)\r
 \r
         return AnyFileName\r
 \r
 \r
         if not os.path.isabs(AnyFileName):\r
             AnyFileName = mws.join(GenFdsGlobalVariable.WorkSpaceDir, AnyFileName)\r
 \r
         return AnyFileName\r
 \r

-    ## __GetAnyFileStatement() method\r
+    ## _GetAnyFileStatement() method\r

     #\r
     #   Get AnyFile for capsule\r
     #\r
     #\r
     #   Get AnyFile for capsule\r
     #\r


@@ -3500,23 +3410,23 @@ class FdfParser:
     #   @retval True        Successfully find a Anyfile statement\r
     #   @retval False       Not able to find a AnyFile statement\r
     #\r
     #   @retval True        Successfully find a Anyfile statement\r
     #   @retval False       Not able to find a AnyFile statement\r
     #\r

-    def __GetAnyFileStatement(self, CapsuleObj, FMPCapsule = False):\r
-        AnyFileName = self.__ParseRawFileStatement()\r
+    def _GetAnyFileStatement(self, CapsuleObj, FMPCapsule = False):\r
+        AnyFileName = self._ParseRawFileStatement()\r

         if not AnyFileName:\r
             return False\r
 \r
         if not AnyFileName:\r
             return False\r
 \r

-        CapsuleAnyFile = CapsuleData.CapsuleAnyFile()\r
-        CapsuleAnyFile.FileName = AnyFileName\r
+        myCapsuleAnyFile = CapsuleAnyFile()\r
+        myCapsuleAnyFile.FileName = AnyFileName\r

         if FMPCapsule:\r
             if not CapsuleObj.ImageFile:\r
         if FMPCapsule:\r
             if not CapsuleObj.ImageFile:\r

-                CapsuleObj.ImageFile.append(CapsuleAnyFile)\r
+                CapsuleObj.ImageFile.append(myCapsuleAnyFile)\r

             else:\r
             else:\r

-                CapsuleObj.VendorCodeFile.append(CapsuleAnyFile)\r
+                CapsuleObj.VendorCodeFile.append(myCapsuleAnyFile)\r

         else:\r
         else:\r

-            CapsuleObj.CapsuleDataList.append(CapsuleAnyFile)\r
+            CapsuleObj.CapsuleDataList.append(myCapsuleAnyFile)\r

         return True\r
         return True\r

-    \r
-    ## __GetAfileStatement() method\r
+\r
+    ## _GetAfileStatement() method\r

     #\r
     #   Get Afile for capsule\r
     #\r
     #\r
     #   Get Afile for capsule\r
     #\r


@@ -3525,39 +3435,38 @@ class FdfParser:
     #   @retval True        Successfully find a Afile statement\r
     #   @retval False       Not able to find a Afile statement\r
     #\r
     #   @retval True        Successfully find a Afile statement\r
     #   @retval False       Not able to find a Afile statement\r
     #\r

-    def __GetAfileStatement(self, CapsuleObj):\r
-\r
-        if not self.__IsKeyword("APPEND"):\r
+    def _GetAfileStatement(self, CapsuleObj):\r
+        if not self._IsKeyword("APPEND"):\r

             return False\r
 \r
             return False\r
 \r

-        if not self.__IsToken("="):\r
-            raise Warning("expected '='", self.FileName, self.CurrentLineNumber)\r
+        if not self._IsToken(TAB_EQUAL_SPLIT):\r
+            raise Warning.ExpectedEquals(self.FileName, self.CurrentLineNumber)\r
+\r
+        if not self._GetNextToken():\r
+            raise Warning.Expected("Afile name", self.FileName, self.CurrentLineNumber)\r

 \r
 \r

-        if not self.__GetNextToken():\r
-            raise Warning("expected Afile name", self.FileName, self.CurrentLineNumber)\r
-        \r
-        AfileName = self.__Token\r
+        AfileName = self._Token\r

         AfileBaseName = os.path.basename(AfileName)\r
         AfileBaseName = os.path.basename(AfileName)\r

-        \r
-        if os.path.splitext(AfileBaseName)[1]  not in [".bin",".BIN",".Bin",".dat",".DAT",".Dat",".data",".DATA",".Data"]:\r
-            raise Warning('invalid binary file type, should be one of "bin","BIN","Bin","dat","DAT","Dat","data","DATA","Data"', \\r
+\r
+        if os.path.splitext(AfileBaseName)[1]  not in {".bin", ".BIN", ".Bin", ".dat", ".DAT", ".Dat", ".data", ".DATA", ".Data"}:\r
+            raise Warning('invalid binary file type, should be one of "bin",BINARY_FILE_TYPE_BIN,"Bin","dat","DAT","Dat","data","DATA","Data"', \\r

                           self.FileName, self.CurrentLineNumber)\r
                           self.FileName, self.CurrentLineNumber)\r

-        \r
+\r

         if not os.path.isabs(AfileName):\r
             AfileName = GenFdsGlobalVariable.ReplaceWorkspaceMacro(AfileName)\r
         if not os.path.isabs(AfileName):\r
             AfileName = GenFdsGlobalVariable.ReplaceWorkspaceMacro(AfileName)\r

-            self.__VerifyFile(AfileName)\r
+            self._VerifyFile(AfileName)\r

         else:\r
             if not os.path.exists(AfileName):\r
                 raise Warning('%s does not exist' % AfileName, self.FileName, self.CurrentLineNumber)\r
             else:\r
                 pass\r
 \r
         else:\r
             if not os.path.exists(AfileName):\r
                 raise Warning('%s does not exist' % AfileName, self.FileName, self.CurrentLineNumber)\r
             else:\r
                 pass\r
 \r

-        CapsuleAfile = CapsuleData.CapsuleAfile()\r
-        CapsuleAfile.FileName = AfileName\r
-        CapsuleObj.CapsuleDataList.append(CapsuleAfile)\r
+        myCapsuleAfile = CapsuleAfile()\r
+        myCapsuleAfile.FileName = AfileName\r
+        CapsuleObj.CapsuleDataList.append(myCapsuleAfile)\r

         return True\r
 \r
         return True\r
 \r

-    ## __GetRule() method\r
+    ## _GetRule() method\r

     #\r
     #   Get Rule section contents and store its data into rule list of self.Profile\r
     #\r
     #\r
     #   Get Rule section contents and store its data into rule list of self.Profile\r
     #\r


@@ -3565,144 +3474,157 @@ class FdfParser:
     #   @retval True        Successfully find a Rule\r
     #   @retval False       Not able to find a Rule\r
     #\r
     #   @retval True        Successfully find a Rule\r
     #   @retval False       Not able to find a Rule\r
     #\r

-    def __GetRule(self):\r
-\r
-        if not self.__GetNextToken():\r
+    def _GetRule(self):\r
+        if not self._GetNextToken():\r

             return False\r
 \r
             return False\r
 \r

-        S = self.__Token.upper()\r
-        if S.startswith("[") and not S.startswith("[RULE."):\r
+        S = self._Token.upper()\r
+        if S.startswith(TAB_SECTION_START) and not S.startswith("[RULE."):\r

             self.SectionParser(S)\r
             self.SectionParser(S)\r

-            self.__UndoToken()\r
+            self._UndoToken()\r

             return False\r
             return False\r

-        self.__UndoToken()\r
-        if not self.__IsToken("[Rule.", True):\r
+        self._UndoToken()\r
+        if not self._IsToken("[Rule.", True):\r

             FileLineTuple = GetRealFileLine(self.FileName, self.CurrentLineNumber)\r
             #print 'Parsing String: %s in File %s, At line: %d, Offset Within Line: %d' \\r
             FileLineTuple = GetRealFileLine(self.FileName, self.CurrentLineNumber)\r
             #print 'Parsing String: %s in File %s, At line: %d, Offset Within Line: %d' \\r

-            #        % (self.Profile.FileLinesList[self.CurrentLineNumber - 1][self.CurrentOffsetWithinLine :], FileLineTuple[0], FileLineTuple[1], self.CurrentOffsetWithinLine)\r
-            raise Warning("expected [Rule.]", self.FileName, self.CurrentLineNumber)\r
+            #        % (self.Profile.FileLinesList[self.CurrentLineNumber - 1][self.CurrentOffsetWithinLine:], FileLineTuple[0], FileLineTuple[1], self.CurrentOffsetWithinLine)\r
+            raise Warning.Expected("[Rule.]", self.FileName, self.CurrentLineNumber)\r

 \r
 \r

-        if not self.__SkipToToken("."):\r
-            raise Warning("expected '.'", self.FileName, self.CurrentLineNumber)\r
+        if not self._SkipToToken(TAB_SPLIT):\r
+            raise Warning.Expected("'.'", self.FileName, self.CurrentLineNumber)\r

 \r
 \r

-        Arch = self.__SkippedChars.rstrip(".")\r
-        if Arch.upper() not in ("IA32", "X64", "IPF", "EBC", "ARM", "AARCH64", "COMMON"):\r
+        Arch = self._SkippedChars.rstrip(TAB_SPLIT)\r
+        if Arch.upper() not in ARCH_SET_FULL:\r

             raise Warning("Unknown Arch '%s'" % Arch, self.FileName, self.CurrentLineNumber)\r
 \r
             raise Warning("Unknown Arch '%s'" % Arch, self.FileName, self.CurrentLineNumber)\r
 \r

-        ModuleType = self.__GetModuleType()\r
+        ModuleType = self._GetModuleType()\r

 \r
         TemplateName = ""\r
 \r
         TemplateName = ""\r

-        if self.__IsToken("."):\r
-            if not self.__GetNextWord():\r
-                raise Warning("expected template name", self.FileName, self.CurrentLineNumber)\r
-            TemplateName = self.__Token\r
+        if self._IsToken(TAB_SPLIT):\r
+            if not self._GetNextWord():\r
+                raise Warning.Expected("template name", self.FileName, self.CurrentLineNumber)\r
+            TemplateName = self._Token\r

 \r
 \r

-        if not self.__IsToken( "]"):\r
-            raise Warning("expected ']'", self.FileName, self.CurrentLineNumber)\r
+        if not self._IsToken(TAB_SECTION_END):\r
+            raise Warning.ExpectedBracketClose(self.FileName, self.CurrentLineNumber)\r

 \r
 \r

-        RuleObj = self.__GetRuleFileStatements()\r
+        RuleObj = self._GetRuleFileStatements()\r

         RuleObj.Arch = Arch.upper()\r
         RuleObj.ModuleType = ModuleType\r
         RuleObj.TemplateName = TemplateName\r
         RuleObj.Arch = Arch.upper()\r
         RuleObj.ModuleType = ModuleType\r
         RuleObj.TemplateName = TemplateName\r

-        if TemplateName == '' :\r
+        if TemplateName == '':\r

             self.Profile.RuleDict['RULE'             + \\r
             self.Profile.RuleDict['RULE'             + \\r

-                              '.'                    + \\r
+                              TAB_SPLIT              + \\r

                               Arch.upper()           + \\r
                               Arch.upper()           + \\r

-                              '.'                    + \\r
+                              TAB_SPLIT              + \\r

                               ModuleType.upper()     ] = RuleObj\r
                               ModuleType.upper()     ] = RuleObj\r

-        else :\r
+        else:\r

             self.Profile.RuleDict['RULE'             + \\r
             self.Profile.RuleDict['RULE'             + \\r

-                              '.'                    + \\r
+                              TAB_SPLIT              + \\r

                               Arch.upper()           + \\r
                               Arch.upper()           + \\r

-                              '.'                    + \\r
+                              TAB_SPLIT              + \\r

                               ModuleType.upper()     + \\r
                               ModuleType.upper()     + \\r

-                              '.'                    + \\r
+                              TAB_SPLIT              + \\r

                               TemplateName.upper() ] = RuleObj\r
                               TemplateName.upper() ] = RuleObj\r

-#        self.Profile.RuleList.append(rule)\r

         return True\r
 \r
         return True\r
 \r

-    ## __GetModuleType() method\r
+    ## _GetModuleType() method\r

     #\r
     #   Return the module type\r
     #\r
     #   @param  self        The object pointer\r
     #   @retval string      module type\r
     #\r
     #\r
     #   Return the module type\r
     #\r
     #   @param  self        The object pointer\r
     #   @retval string      module type\r
     #\r

-    def __GetModuleType(self):\r
-\r
-        if not self.__GetNextWord():\r
-            raise Warning("expected Module type", self.FileName, self.CurrentLineNumber)\r
-        if self.__Token.upper() not in ("SEC", "PEI_CORE", "PEIM", "DXE_CORE", \\r
-                             "DXE_DRIVER", "DXE_SAL_DRIVER", \\r
-                             "DXE_SMM_DRIVER", "DXE_RUNTIME_DRIVER", \\r
-                             "UEFI_DRIVER", "UEFI_APPLICATION", "USER_DEFINED", "DEFAULT", "BASE", \\r
-                             "SECURITY_CORE", "COMBINED_PEIM_DRIVER", "PIC_PEIM", "RELOCATABLE_PEIM", \\r
-                                        "PE32_PEIM", "BS_DRIVER", "RT_DRIVER", "SAL_RT_DRIVER", "APPLICATION", "ACPITABLE", "SMM_CORE", "MM_STANDALONE", "MM_CORE_STANDALONE"):\r
-            raise Warning("Unknown Module type '%s'" % self.__Token, self.FileName, self.CurrentLineNumber)\r
-        return self.__Token\r
-\r
-    ## __GetFileExtension() method\r
+    def _GetModuleType(self):\r
+        if not self._GetNextWord():\r
+            raise Warning.Expected("Module type", self.FileName, self.CurrentLineNumber)\r
+        if self._Token.upper() not in {\r
+                SUP_MODULE_SEC, SUP_MODULE_PEI_CORE, SUP_MODULE_PEIM,\r
+                SUP_MODULE_DXE_CORE, SUP_MODULE_DXE_DRIVER,\r
+                SUP_MODULE_DXE_SAL_DRIVER, SUP_MODULE_DXE_SMM_DRIVER,\r
+                SUP_MODULE_DXE_RUNTIME_DRIVER, SUP_MODULE_UEFI_DRIVER,\r
+                SUP_MODULE_UEFI_APPLICATION, SUP_MODULE_USER_DEFINED,\r
+                TAB_DEFAULT, SUP_MODULE_BASE,\r
+                EDK_COMPONENT_TYPE_SECURITY_CORE,\r
+                EDK_COMPONENT_TYPE_COMBINED_PEIM_DRIVER,\r
+                EDK_COMPONENT_TYPE_PIC_PEIM,\r
+                EDK_COMPONENT_TYPE_RELOCATABLE_PEIM, "PE32_PEIM",\r
+                EDK_COMPONENT_TYPE_BS_DRIVER, EDK_COMPONENT_TYPE_RT_DRIVER,\r
+                EDK_COMPONENT_TYPE_SAL_RT_DRIVER,\r
+                EDK_COMPONENT_TYPE_APPLICATION, "ACPITABLE",\r
+                SUP_MODULE_SMM_CORE, SUP_MODULE_MM_STANDALONE,\r
+                SUP_MODULE_MM_CORE_STANDALONE}:\r
+            raise Warning("Unknown Module type '%s'" % self._Token, self.FileName, self.CurrentLineNumber)\r
+        return self._Token\r
+\r
+    ## _GetFileExtension() method\r

     #\r
     #   Return the file extension\r
     #\r
     #   @param  self        The object pointer\r
     #   @retval string      file name extension\r
     #\r
     #\r
     #   Return the file extension\r
     #\r
     #   @param  self        The object pointer\r
     #   @retval string      file name extension\r
     #\r

-    def __GetFileExtension(self):\r
-        if not self.__IsToken("."):\r
-            raise Warning("expected '.'", self.FileName, self.CurrentLineNumber)\r
+    def _GetFileExtension(self):\r
+        if not self._IsToken(TAB_SPLIT):\r
+            raise Warning.Expected("'.'", self.FileName, self.CurrentLineNumber)\r

 \r
         Ext = ""\r
 \r
         Ext = ""\r

-        if self.__GetNextToken():\r
-            if FileExtensionPattern.match(self.__Token):\r
-                Ext = self.__Token\r
-                return '.' + Ext\r
+        if self._GetNextToken():\r
+            if FileExtensionPattern.match(self._Token):\r
+                Ext = self._Token\r
+                return TAB_SPLIT + Ext\r

             else:\r
             else:\r

-                raise Warning("Unknown file extension '%s'" % self.__Token, self.FileName, self.CurrentLineNumber)\r
+                raise Warning("Unknown file extension '%s'" % self._Token, self.FileName, self.CurrentLineNumber)\r

 \r
         else:\r
 \r
         else:\r

-            raise Warning("expected file extension", self.FileName, self.CurrentLineNumber)\r
+            raise Warning.Expected("file extension", self.FileName, self.CurrentLineNumber)\r

 \r
 \r

-    ## __GetRuleFileStatement() method\r
+    ## _GetRuleFileStatement() method\r

     #\r
     #   Get rule contents\r
     #\r
     #   @param  self        The object pointer\r
     #   @retval Rule        Rule object\r
     #\r
     #\r
     #   Get rule contents\r
     #\r
     #   @param  self        The object pointer\r
     #   @retval Rule        Rule object\r
     #\r

-    def __GetRuleFileStatements(self):\r
-\r
-        if not self.__IsKeyword("FILE"):\r
-            raise Warning("expected FILE", self.FileName, self.CurrentLineNumber)\r
-\r
-        if not self.__GetNextWord():\r
-            raise Warning("expected FFS type", self.FileName, self.CurrentLineNumber)\r
-\r
-        Type = self.__Token.strip().upper()\r
-        if Type not in ("RAW", "FREEFORM", "SEC", "PEI_CORE", "PEIM",\\r
-                             "PEI_DXE_COMBO", "DRIVER", "DXE_CORE", "APPLICATION", "FV_IMAGE", "SMM", "SMM_CORE", "MM_STANDALONE", "MM_CORE_STANDALONE"):\r
-            raise Warning("Unknown FV type '%s'" % self.__Token, self.FileName, self.CurrentLineNumber)\r
-\r
-        if not self.__IsToken("="):\r
-            raise Warning("expected '='", self.FileName, self.CurrentLineNumber)\r
+    def _GetRuleFileStatements(self):\r
+        if not self._IsKeyword("FILE"):\r
+            raise Warning.Expected("FILE", self.FileName, self.CurrentLineNumber)\r
+\r
+        if not self._GetNextWord():\r
+            raise Warning.Expected("FFS type", self.FileName, self.CurrentLineNumber)\r
+\r
+        Type = self._Token.strip().upper()\r
+        if Type not in {"RAW", "FREEFORM", SUP_MODULE_SEC, SUP_MODULE_PEI_CORE, SUP_MODULE_PEIM,\r
+                        "PEI_DXE_COMBO", "DRIVER", SUP_MODULE_DXE_CORE, EDK_COMPONENT_TYPE_APPLICATION,\r
+                        "FV_IMAGE", "SMM", SUP_MODULE_SMM_CORE, SUP_MODULE_MM_STANDALONE,\r
+                        SUP_MODULE_MM_CORE_STANDALONE}:\r
+            raise Warning("Unknown FV type '%s'" % self._Token, self.FileName, self.CurrentLineNumber)\r
+\r
+        if not self._IsToken(TAB_EQUAL_SPLIT):\r
+            raise Warning.ExpectedEquals(self.FileName, self.CurrentLineNumber)\r
+\r
+        if not self._IsKeyword("$(NAMED_GUID)"):\r
+            if not self._GetNextWord():\r
+                NamedGuid = self._CurrentLine()[self.CurrentOffsetWithinLine:].split()[0].strip()\r
+                if GlobalData.gGuidPatternEnd.match(NamedGuid):\r
+                    self.CurrentOffsetWithinLine += len(NamedGuid)\r
+                    self._Token = NamedGuid\r
+                else:\r
+                    raise Warning.Expected("$(NAMED_GUID)", self.FileName, self.CurrentLineNumber)\r
+            if self._Token == 'PCD':\r
+                if not self._IsToken("("):\r
+                    raise Warning.Expected("'('", self.FileName, self.CurrentLineNumber)\r
+                PcdPair = self._GetNextPcdSettings()\r
+                if not self._IsToken(")"):\r
+                    raise Warning.Expected("')'", self.FileName, self.CurrentLineNumber)\r
+                self._Token = 'PCD('+PcdPair[1]+TAB_SPLIT+PcdPair[0]+')'\r

 \r
 \r

-        if not self.__IsKeyword("$(NAMED_GUID)"):\r
-            if not self.__GetNextWord():\r
-                raise Warning("expected $(NAMED_GUID)", self.FileName, self.CurrentLineNumber)\r
-            if self.__Token == 'PCD':\r
-                if not self.__IsToken( "("):\r
-                    raise Warning("expected '('", self.FileName, self.CurrentLineNumber)\r
-                PcdPair = self.__GetNextPcdName()\r
-                if not self.__IsToken( ")"):\r
-                    raise Warning("expected ')'", self.FileName, self.CurrentLineNumber)\r
-                self.__Token = 'PCD('+PcdPair[1]+'.'+PcdPair[0]+')'\r
-            \r
-        NameGuid = self.__Token\r
+        NameGuid = self._Token\r

 \r
         KeepReloc = None\r
 \r
         KeepReloc = None\r

-        if self.__IsKeyword('RELOCS_STRIPPED') or self.__IsKeyword('RELOCS_RETAINED'):\r
-            if self.__FileCouldHaveRelocFlag(Type):\r
-                if self.__Token == 'RELOCS_STRIPPED':\r
+        if self._IsKeyword('RELOCS_STRIPPED') or self._IsKeyword('RELOCS_RETAINED'):\r
+            if self._FileCouldHaveRelocFlag(Type):\r
+                if self._Token == 'RELOCS_STRIPPED':\r

                     KeepReloc = False\r
                 else:\r
                     KeepReloc = True\r
                     KeepReloc = False\r
                 else:\r
                     KeepReloc = True\r


@@ -3710,111 +3632,113 @@ class FdfParser:
                 raise Warning("File type %s could not have reloc strip flag%d" % (Type, self.CurrentLineNumber), self.FileName, self.CurrentLineNumber)\r
 \r
         KeyStringList = []\r
                 raise Warning("File type %s could not have reloc strip flag%d" % (Type, self.CurrentLineNumber), self.FileName, self.CurrentLineNumber)\r
 \r
         KeyStringList = []\r

-        if self.__GetNextToken():\r
-            if TokenFindPattern.match(self.__Token):\r
-                KeyStringList.append(self.__Token)\r
-                if self.__IsToken(","):\r
-                    while self.__GetNextToken():\r
-                        if not TokenFindPattern.match(self.__Token):\r
-                            raise Warning("expected KeyString \"Target_Tag_Arch\"", self.FileName, self.CurrentLineNumber)\r
-                        KeyStringList.append(self.__Token)\r
-\r
-                        if not self.__IsToken(","):\r
+        if self._GetNextToken():\r
+            if TokenFindPattern.match(self._Token):\r
+                KeyStringList.append(self._Token)\r
+                if self._IsToken(TAB_COMMA_SPLIT):\r
+                    while self._GetNextToken():\r
+                        if not TokenFindPattern.match(self._Token):\r
+                            raise Warning.Expected("KeyString \"Target_Tag_Arch\"", self.FileName, self.CurrentLineNumber)\r
+                        KeyStringList.append(self._Token)\r
+\r
+                        if not self._IsToken(TAB_COMMA_SPLIT):\r

                             break\r
 \r
             else:\r
                             break\r
 \r
             else:\r

-                self.__UndoToken()\r
+                self._UndoToken()\r

 \r
 \r
         Fixed = False\r
 \r
 \r
         Fixed = False\r

-        if self.__IsKeyword("Fixed", True):\r
+        if self._IsKeyword("Fixed", True):\r

             Fixed = True\r
 \r
         CheckSum = False\r
             Fixed = True\r
 \r
         CheckSum = False\r

-        if self.__IsKeyword("CheckSum", True):\r
+        if self._IsKeyword("CheckSum", True):\r

             CheckSum = True\r
 \r
         AlignValue = ""\r
             CheckSum = True\r
 \r
         AlignValue = ""\r

-        if self.__GetAlignment():\r
-            if self.__Token not in ("Auto", "8", "16", "32", "64", "128", "512", "1K", "4K", "32K" ,"64K", "128K",\r
-                                    "256K", "512K", "1M", "2M", "4M", "8M", "16M"):\r
-                raise Warning("Incorrect alignment '%s'" % self.__Token, self.FileName, self.CurrentLineNumber)\r
+        if self._GetAlignment():\r
+            if self._Token not in ALIGNMENTS:\r
+                raise Warning("Incorrect alignment '%s'" % self._Token, self.FileName, self.CurrentLineNumber)\r

             #For FFS, Auto is default option same to ""\r
             #For FFS, Auto is default option same to ""\r

-            if not self.__Token == "Auto":\r
-                AlignValue = self.__Token\r
+            if not self._Token == "Auto":\r
+                AlignValue = self._Token\r

 \r
 \r

-        if self.__IsToken("{"):\r
+        if self._IsToken("{"):\r

             # Complex file rule expected\r
             # Complex file rule expected\r

-            Rule = RuleComplexFile.RuleComplexFile()\r
-            Rule.FvFileType = Type\r
-            Rule.NameGuid = NameGuid\r
-            Rule.Alignment = AlignValue\r
-            Rule.CheckSum = CheckSum\r
-            Rule.Fixed = Fixed\r
-            Rule.KeyStringList = KeyStringList\r
+            NewRule = RuleComplexFile()\r
+            NewRule.FvFileType = Type\r
+            NewRule.NameGuid = NameGuid\r
+            NewRule.Alignment = AlignValue\r
+            NewRule.CheckSum = CheckSum\r
+            NewRule.Fixed = Fixed\r
+            NewRule.KeyStringList = KeyStringList\r

             if KeepReloc is not None:\r
             if KeepReloc is not None:\r

-                Rule.KeepReloc = KeepReloc\r
+                NewRule.KeepReloc = KeepReloc\r

 \r
             while True:\r
 \r
             while True:\r

-                IsEncapsulate = self.__GetRuleEncapsulationSection(Rule)\r
-                IsLeaf = self.__GetEfiSection(Rule)\r
+                IsEncapsulate = self._GetRuleEncapsulationSection(NewRule)\r
+                IsLeaf = self._GetEfiSection(NewRule)\r

                 if not IsEncapsulate and not IsLeaf:\r
                     break\r
 \r
                 if not IsEncapsulate and not IsLeaf:\r
                     break\r
 \r

-            if not self.__IsToken("}"):\r
-                raise Warning("expected '}'", self.FileName, self.CurrentLineNumber)\r
+            if not self._IsToken(T_CHAR_BRACE_R):\r
+                raise Warning.ExpectedCurlyClose(self.FileName, self.CurrentLineNumber)\r

 \r
 \r

-            return Rule\r
+            return NewRule\r

 \r
         else:\r
             # Simple file rule expected\r
 \r
         else:\r
             # Simple file rule expected\r

-            if not self.__GetNextWord():\r
-                raise Warning("expected leaf section type", self.FileName, self.CurrentLineNumber)\r
+            if not self._GetNextWord():\r
+                raise Warning.Expected("leaf section type", self.FileName, self.CurrentLineNumber)\r

 \r
 \r

-            SectionName = self.__Token\r
+            SectionName = self._Token\r

 \r
 \r

-            if SectionName not in ("COMPAT16", "PE32", "PIC", "TE", "FV_IMAGE", "RAW", "DXE_DEPEX",\\r
-                                    "UI", "PEI_DEPEX", "VERSION", "SUBTYPE_GUID", "SMM_DEPEX"):\r
+            if SectionName not in {\r
+                    "COMPAT16", BINARY_FILE_TYPE_PE32,\r
+                    BINARY_FILE_TYPE_PIC, BINARY_FILE_TYPE_TE, "FV_IMAGE",\r
+                    "RAW",BINARY_FILE_TYPE_DXE_DEPEX, BINARY_FILE_TYPE_UI,\r
+                    BINARY_FILE_TYPE_PEI_DEPEX, "VERSION", "SUBTYPE_GUID",\r
+                    BINARY_FILE_TYPE_SMM_DEPEX}:\r

                 raise Warning("Unknown leaf section name '%s'" % SectionName, self.FileName, self.CurrentLineNumber)\r
 \r
 \r
                 raise Warning("Unknown leaf section name '%s'" % SectionName, self.FileName, self.CurrentLineNumber)\r
 \r
 \r

-            if self.__IsKeyword("Fixed", True):\r
+            if self._IsKeyword("Fixed", True):\r

                 Fixed = True\r
 \r
                 Fixed = True\r
 \r

-            if self.__IsKeyword("CheckSum", True):\r
+            if self._IsKeyword("CheckSum", True):\r

                 CheckSum = True\r
 \r
             SectAlignment = ""\r
                 CheckSum = True\r
 \r
             SectAlignment = ""\r

-            if self.__GetAlignment():\r
-                if self.__Token not in ("Auto", "8", "16", "32", "64", "128", "512", "1K", "4K", "32K" ,"64K", "128K",\r
-                                        "256K", "512K", "1M", "2M", "4M", "8M", "16M"):\r
-                    raise Warning("Incorrect alignment '%s'" % self.__Token, self.FileName, self.CurrentLineNumber)\r
-                if self.__Token == 'Auto' and (not SectionName == 'PE32') and (not SectionName == 'TE'):\r
+            if self._GetAlignment():\r
+                if self._Token not in ALIGNMENTS:\r
+                    raise Warning("Incorrect alignment '%s'" % self._Token, self.FileName, self.CurrentLineNumber)\r
+                if self._Token == 'Auto' and (not SectionName == BINARY_FILE_TYPE_PE32) and (not SectionName == BINARY_FILE_TYPE_TE):\r

                     raise Warning("Auto alignment can only be used in PE32 or TE section ", self.FileName, self.CurrentLineNumber)\r
                     raise Warning("Auto alignment can only be used in PE32 or TE section ", self.FileName, self.CurrentLineNumber)\r

-                SectAlignment = self.__Token\r
+                SectAlignment = self._Token\r

 \r
             Ext = None\r
 \r
             Ext = None\r

-            if self.__IsToken('|'):\r
-                Ext = self.__GetFileExtension()\r
-            elif not self.__GetNextToken():\r
-                raise Warning("expected File name", self.FileName, self.CurrentLineNumber)\r
-\r
-            Rule = RuleSimpleFile.RuleSimpleFile()\r
-            Rule.SectionType = SectionName\r
-            Rule.FvFileType = Type\r
-            Rule.NameGuid = NameGuid\r
-            Rule.Alignment = AlignValue\r
-            Rule.SectAlignment = SectAlignment\r
-            Rule.CheckSum = CheckSum\r
-            Rule.Fixed = Fixed\r
-            Rule.KeyStringList = KeyStringList\r
+            if self._IsToken(TAB_VALUE_SPLIT):\r
+                Ext = self._GetFileExtension()\r
+            elif not self._GetNextToken():\r
+                raise Warning.Expected("File name", self.FileName, self.CurrentLineNumber)\r
+\r
+            NewRule = RuleSimpleFile()\r
+            NewRule.SectionType = SectionName\r
+            NewRule.FvFileType = Type\r
+            NewRule.NameGuid = NameGuid\r
+            NewRule.Alignment = AlignValue\r
+            NewRule.SectAlignment = SectAlignment\r
+            NewRule.CheckSum = CheckSum\r
+            NewRule.Fixed = Fixed\r
+            NewRule.KeyStringList = KeyStringList\r

             if KeepReloc is not None:\r
             if KeepReloc is not None:\r

-                Rule.KeepReloc = KeepReloc\r
-            Rule.FileExtension = Ext\r
-            Rule.FileName = self.__Token\r
-            return Rule\r
+                NewRule.KeepReloc = KeepReloc\r
+            NewRule.FileExtension = Ext\r
+            NewRule.FileName = self._Token\r
+            return NewRule\r

 \r
 \r

-    ## __GetEfiSection() method\r
+    ## _GetEfiSection() method\r

     #\r
     #   Get section list for Rule\r
     #\r
     #\r
     #   Get section list for Rule\r
     #\r


@@ -3823,127 +3747,143 @@ class FdfParser:
     #   @retval True        Successfully find section statement\r
     #   @retval False       Not able to find section statement\r
     #\r
     #   @retval True        Successfully find section statement\r
     #   @retval False       Not able to find section statement\r
     #\r

-    def __GetEfiSection(self, Obj):\r
-\r
+    def _GetEfiSection(self, Obj):\r

         OldPos = self.GetFileBufferPos()\r
         OldPos = self.GetFileBufferPos()\r

-        if not self.__GetNextWord():\r
-            return False\r
-        SectionName = self.__Token\r
-\r
-        if SectionName not in ("COMPAT16", "PE32", "PIC", "TE", "FV_IMAGE", "RAW", "DXE_DEPEX",\\r
-                               "UI", "VERSION", "PEI_DEPEX", "GUID", "SMM_DEPEX"):\r
-            self.__UndoToken()\r
+        EfiSectionObj = EfiSection()\r
+        if not self._GetNextWord():\r
+            CurrentLine = self._CurrentLine()[self.CurrentOffsetWithinLine:].split()[0].strip()\r
+            if self._Token == '{' and Obj.FvFileType == "RAW" and TAB_SPLIT in CurrentLine:\r
+                if self._IsToken(TAB_VALUE_SPLIT):\r
+                    EfiSectionObj.FileExtension = self._GetFileExtension()\r
+                elif self._GetNextToken():\r
+                    EfiSectionObj.FileName = self._Token\r
+                EfiSectionObj.SectionType = BINARY_FILE_TYPE_RAW\r
+                Obj.SectionList.append(EfiSectionObj)\r
+                return True\r
+            else:\r
+                return False\r
+        SectionName = self._Token\r
+\r
+        if SectionName not in {\r
+                    "COMPAT16", BINARY_FILE_TYPE_PE32,\r
+                    BINARY_FILE_TYPE_PIC, BINARY_FILE_TYPE_TE, "FV_IMAGE",\r
+                    "RAW",BINARY_FILE_TYPE_DXE_DEPEX, BINARY_FILE_TYPE_UI,\r
+                    BINARY_FILE_TYPE_PEI_DEPEX, "VERSION", "SUBTYPE_GUID",\r
+                    BINARY_FILE_TYPE_SMM_DEPEX, BINARY_FILE_TYPE_GUID}:\r
+            self._UndoToken()\r

             return False\r
 \r
         if SectionName == "FV_IMAGE":\r
             return False\r
 \r
         if SectionName == "FV_IMAGE":\r

-            FvImageSectionObj = FvImageSection.FvImageSection()\r
-            if self.__IsKeyword("FV_IMAGE"):\r
+            FvImageSectionObj = FvImageSection()\r
+            if self._IsKeyword("FV_IMAGE"):\r

                 pass\r
                 pass\r

-            if self.__IsToken( "{"):\r
-                FvObj = Fv.FV()\r
-                self.__GetDefineStatements(FvObj)\r
-                self.__GetBlockStatement(FvObj)\r
-                self.__GetSetStatements(FvObj)\r
-                self.__GetFvAlignment(FvObj)\r
-                self.__GetFvAttributes(FvObj)\r
-                self.__GetAprioriSection(FvObj)\r
-                self.__GetAprioriSection(FvObj)\r
+            if self._IsToken("{"):\r
+                FvObj = FV()\r
+                self._GetDefineStatements(FvObj)\r
+                self._GetBlockStatement(FvObj)\r
+                self._GetSetStatements(FvObj)\r
+                self._GetFvAlignment(FvObj)\r
+                self._GetFvAttributes(FvObj)\r
+                self._GetAprioriSection(FvObj)\r
+                self._GetAprioriSection(FvObj)\r

 \r
                 while True:\r
 \r
                 while True:\r

-                    IsInf = self.__GetInfStatement(FvObj)\r
-                    IsFile = self.__GetFileStatement(FvObj)\r
+                    IsInf = self._GetInfStatement(FvObj)\r
+                    IsFile = self._GetFileStatement(FvObj)\r

                     if not IsInf and not IsFile:\r
                         break\r
 \r
                     if not IsInf and not IsFile:\r
                         break\r
 \r

-                if not self.__IsToken( "}"):\r
-                    raise Warning("expected '}'", self.FileName, self.CurrentLineNumber)\r
+                if not self._IsToken(T_CHAR_BRACE_R):\r
+                    raise Warning.ExpectedCurlyClose(self.FileName, self.CurrentLineNumber)\r

                 FvImageSectionObj.Fv = FvObj\r
                 FvImageSectionObj.FvName = None\r
 \r
             else:\r
                 FvImageSectionObj.Fv = FvObj\r
                 FvImageSectionObj.FvName = None\r
 \r
             else:\r

-                if not self.__IsKeyword("FV"):\r
-                    raise Warning("expected 'FV'", self.FileName, self.CurrentLineNumber)\r
-                FvImageSectionObj.FvFileType = self.__Token\r
-\r
-                if self.__GetAlignment():\r
-                    if self.__Token not in ("8", "16", "32", "64", "128", "512", "1K", "4K", "32K" ,"64K", "128K",\r
-                                            "256K", "512K", "1M", "2M", "4M", "8M", "16M"):\r
-                        raise Warning("Incorrect alignment '%s'" % self.__Token, self.FileName, self.CurrentLineNumber)\r
-                    FvImageSectionObj.Alignment = self.__Token\r
-\r
-                if self.__IsToken('|'):\r
-                    FvImageSectionObj.FvFileExtension = self.__GetFileExtension()\r
-                elif self.__GetNextToken():\r
-                    if self.__Token not in ("}", "COMPAT16", "PE32", "PIC", "TE", "FV_IMAGE", "RAW", "DXE_DEPEX",\\r
-                               "UI", "VERSION", "PEI_DEPEX", "GUID", "SMM_DEPEX"):\r
-                        FvImageSectionObj.FvFileName = self.__Token\r
+                if not self._IsKeyword(BINARY_FILE_TYPE_FV):\r
+                    raise Warning.Expected("'FV'", self.FileName, self.CurrentLineNumber)\r
+                FvImageSectionObj.FvFileType = self._Token\r
+\r
+                if self._GetAlignment():\r
+                    if self._Token not in ALIGNMENT_NOAUTO:\r
+                        raise Warning("Incorrect alignment '%s'" % self._Token, self.FileName, self.CurrentLineNumber)\r
+                    FvImageSectionObj.Alignment = self._Token\r
+\r
+                if self._IsToken(TAB_VALUE_SPLIT):\r
+                    FvImageSectionObj.FvFileExtension = self._GetFileExtension()\r
+                elif self._GetNextToken():\r
+                    if self._Token not in {\r
+                            T_CHAR_BRACE_R, "COMPAT16", BINARY_FILE_TYPE_PE32,\r
+                            BINARY_FILE_TYPE_PIC, BINARY_FILE_TYPE_TE,\r
+                            "FV_IMAGE", "RAW", BINARY_FILE_TYPE_DXE_DEPEX,\r
+                            BINARY_FILE_TYPE_UI, "VERSION",\r
+                            BINARY_FILE_TYPE_PEI_DEPEX, BINARY_FILE_TYPE_GUID,\r
+                            BINARY_FILE_TYPE_SMM_DEPEX}:\r
+                        FvImageSectionObj.FvFileName = self._Token\r

                     else:\r
                     else:\r

-                        self.__UndoToken()\r
+                        self._UndoToken()\r

                 else:\r
                 else:\r

-                    raise Warning("expected FV file name", self.FileName, self.CurrentLineNumber)\r
+                    raise Warning.Expected("FV file name", self.FileName, self.CurrentLineNumber)\r

 \r
             Obj.SectionList.append(FvImageSectionObj)\r
             return True\r
 \r
 \r
             Obj.SectionList.append(FvImageSectionObj)\r
             return True\r
 \r

-        EfiSectionObj = EfiSection.EfiSection()\r

         EfiSectionObj.SectionType = SectionName\r
 \r
         EfiSectionObj.SectionType = SectionName\r
 \r

-        if not self.__GetNextToken():\r
-            raise Warning("expected file type", self.FileName, self.CurrentLineNumber)\r
+        if not self._GetNextToken():\r
+            raise Warning.Expected("file type", self.FileName, self.CurrentLineNumber)\r

 \r
 \r

-        if self.__Token == "STRING":\r
-            if not self.__RuleSectionCouldHaveString(EfiSectionObj.SectionType):\r
+        if self._Token == "STRING":\r
+            if not self._RuleSectionCouldHaveString(EfiSectionObj.SectionType):\r

                 raise Warning("%s section could NOT have string data%d" % (EfiSectionObj.SectionType, self.CurrentLineNumber), self.FileName, self.CurrentLineNumber)\r
 \r
                 raise Warning("%s section could NOT have string data%d" % (EfiSectionObj.SectionType, self.CurrentLineNumber), self.FileName, self.CurrentLineNumber)\r
 \r

-            if not self.__IsToken('='):\r
-                raise Warning("expected '='", self.FileName, self.CurrentLineNumber)\r
+            if not self._IsToken(TAB_EQUAL_SPLIT):\r
+                raise Warning.ExpectedEquals(self.FileName, self.CurrentLineNumber)\r

 \r
 \r

-            if not self.__GetNextToken():\r
-                raise Warning("expected Quoted String", self.FileName, self.CurrentLineNumber)\r
+            if not self._GetNextToken():\r
+                raise Warning.Expected("Quoted String", self.FileName, self.CurrentLineNumber)\r

 \r
 \r

-            if self.__GetStringData():\r
-                EfiSectionObj.StringData = self.__Token\r
+            if self._GetStringData():\r
+                EfiSectionObj.StringData = self._Token\r

 \r
 \r

-            if self.__IsKeyword("BUILD_NUM"):\r
-                if not self.__RuleSectionCouldHaveBuildNum(EfiSectionObj.SectionType):\r
+            if self._IsKeyword("BUILD_NUM"):\r
+                if not self._RuleSectionCouldHaveBuildNum(EfiSectionObj.SectionType):\r

                     raise Warning("%s section could NOT have BUILD_NUM%d" % (EfiSectionObj.SectionType, self.CurrentLineNumber), self.FileName, self.CurrentLineNumber)\r
 \r
                     raise Warning("%s section could NOT have BUILD_NUM%d" % (EfiSectionObj.SectionType, self.CurrentLineNumber), self.FileName, self.CurrentLineNumber)\r
 \r

-                if not self.__IsToken("="):\r
-                    raise Warning("expected '='", self.FileName, self.CurrentLineNumber)\r
-                if not self.__GetNextToken():\r
-                    raise Warning("expected Build number", self.FileName, self.CurrentLineNumber)\r
-                EfiSectionObj.BuildNum = self.__Token\r
+                if not self._IsToken(TAB_EQUAL_SPLIT):\r
+                    raise Warning.ExpectedEquals(self.FileName, self.CurrentLineNumber)\r
+                if not self._GetNextToken():\r
+                    raise Warning.Expected("Build number", self.FileName, self.CurrentLineNumber)\r
+                EfiSectionObj.BuildNum = self._Token\r

 \r
         else:\r
 \r
         else:\r

-            EfiSectionObj.FileType = self.__Token\r
-            self.__CheckRuleSectionFileType(EfiSectionObj.SectionType, EfiSectionObj.FileType)\r
+            EfiSectionObj.FileType = self._Token\r
+            self._CheckRuleSectionFileType(EfiSectionObj.SectionType, EfiSectionObj.FileType)\r

 \r
 \r

-        if self.__IsKeyword("Optional"):\r
-            if not self.__RuleSectionCouldBeOptional(EfiSectionObj.SectionType):\r
+        if self._IsKeyword("Optional"):\r
+            if not self._RuleSectionCouldBeOptional(EfiSectionObj.SectionType):\r

                 raise Warning("%s section could NOT be optional%d" % (EfiSectionObj.SectionType, self.CurrentLineNumber), self.FileName, self.CurrentLineNumber)\r
             EfiSectionObj.Optional = True\r
 \r
                 raise Warning("%s section could NOT be optional%d" % (EfiSectionObj.SectionType, self.CurrentLineNumber), self.FileName, self.CurrentLineNumber)\r
             EfiSectionObj.Optional = True\r
 \r

-            if self.__IsKeyword("BUILD_NUM"):\r
-                if not self.__RuleSectionCouldHaveBuildNum(EfiSectionObj.SectionType):\r
+            if self._IsKeyword("BUILD_NUM"):\r
+                if not self._RuleSectionCouldHaveBuildNum(EfiSectionObj.SectionType):\r

                     raise Warning("%s section could NOT have BUILD_NUM%d" % (EfiSectionObj.SectionType, self.CurrentLineNumber), self.FileName, self.CurrentLineNumber)\r
 \r
                     raise Warning("%s section could NOT have BUILD_NUM%d" % (EfiSectionObj.SectionType, self.CurrentLineNumber), self.FileName, self.CurrentLineNumber)\r
 \r

-                if not self.__IsToken("="):\r
-                    raise Warning("expected '='", self.FileName, self.CurrentLineNumber)\r
-                if not self.__GetNextToken():\r
-                    raise Warning("expected Build number", self.FileName, self.CurrentLineNumber)\r
-                EfiSectionObj.BuildNum = self.__Token\r
-\r
-        if self.__GetAlignment():\r
-            if self.__Token not in ("Auto", "8", "16", "32", "64", "128", "512", "1K", "4K", "32K" ,"64K", "128K",\r
-                                    "256K", "512K", "1M", "2M", "4M", "8M", "16M"):\r
-                raise Warning("Incorrect alignment '%s'" % self.__Token, self.FileName, self.CurrentLineNumber)\r
-            if self.__Token == 'Auto' and (not SectionName == 'PE32') and (not SectionName == 'TE'):\r
+                if not self._IsToken(TAB_EQUAL_SPLIT):\r
+                    raise Warning.ExpectedEquals(self.FileName, self.CurrentLineNumber)\r
+                if not self._GetNextToken():\r
+                    raise Warning.Expected("Build number", self.FileName, self.CurrentLineNumber)\r
+                EfiSectionObj.BuildNum = self._Token\r
+\r
+        if self._GetAlignment():\r
+            if self._Token not in ALIGNMENTS:\r
+                raise Warning("Incorrect alignment '%s'" % self._Token, self.FileName, self.CurrentLineNumber)\r
+            if self._Token == 'Auto' and (not SectionName == BINARY_FILE_TYPE_PE32) and (not SectionName == BINARY_FILE_TYPE_TE):\r

                 raise Warning("Auto alignment can only be used in PE32 or TE section ", self.FileName, self.CurrentLineNumber)\r
                 raise Warning("Auto alignment can only be used in PE32 or TE section ", self.FileName, self.CurrentLineNumber)\r

-            EfiSectionObj.Alignment = self.__Token\r
+            EfiSectionObj.Alignment = self._Token\r

 \r
 \r

-        if self.__IsKeyword('RELOCS_STRIPPED') or self.__IsKeyword('RELOCS_RETAINED'):\r
-            if self.__SectionCouldHaveRelocFlag(EfiSectionObj.SectionType):\r
-                if self.__Token == 'RELOCS_STRIPPED':\r
+        if self._IsKeyword('RELOCS_STRIPPED') or self._IsKeyword('RELOCS_RETAINED'):\r
+            if self._SectionCouldHaveRelocFlag(EfiSectionObj.SectionType):\r
+                if self._Token == 'RELOCS_STRIPPED':\r

                     EfiSectionObj.KeepReloc = False\r
                 else:\r
                     EfiSectionObj.KeepReloc = True\r
                     EfiSectionObj.KeepReloc = False\r
                 else:\r
                     EfiSectionObj.KeepReloc = True\r


@@ -3953,35 +3893,40 @@ class FdfParser:
                 raise Warning("Section type %s could not have reloc strip flag" % EfiSectionObj.SectionType, self.FileName, self.CurrentLineNumber)\r
 \r
 \r
                 raise Warning("Section type %s could not have reloc strip flag" % EfiSectionObj.SectionType, self.FileName, self.CurrentLineNumber)\r
 \r
 \r

-        if self.__IsToken('|'):\r
-            EfiSectionObj.FileExtension = self.__GetFileExtension()\r
-        elif self.__GetNextToken():\r
-            if self.__Token not in ("}", "COMPAT16", "PE32", "PIC", "TE", "FV_IMAGE", "RAW", "DXE_DEPEX",\\r
-                       "UI", "VERSION", "PEI_DEPEX", "GUID", "SMM_DEPEX"):\r
-                \r
-                if self.__Token.startswith('PCD'):\r
-                    self.__UndoToken()\r
-                    self.__GetNextWord()\r
-                \r
-                    if self.__Token == 'PCD':\r
-                        if not self.__IsToken( "("):\r
-                            raise Warning("expected '('", self.FileName, self.CurrentLineNumber)\r
-                        PcdPair = self.__GetNextPcdName()\r
-                        if not self.__IsToken( ")"):\r
-                            raise Warning("expected ')'", self.FileName, self.CurrentLineNumber)\r
-                        self.__Token = 'PCD('+PcdPair[1]+'.'+PcdPair[0]+')'\r
-                        \r
-                EfiSectionObj.FileName = self.__Token        \r
-                            \r
+        if self._IsToken(TAB_VALUE_SPLIT):\r
+            EfiSectionObj.FileExtension = self._GetFileExtension()\r
+        elif self._GetNextToken():\r
+            if self._Token not in {\r
+                    T_CHAR_BRACE_R, "COMPAT16", BINARY_FILE_TYPE_PE32,\r
+                    BINARY_FILE_TYPE_PIC, BINARY_FILE_TYPE_TE,\r
+                    "FV_IMAGE", "RAW", BINARY_FILE_TYPE_DXE_DEPEX,\r
+                    BINARY_FILE_TYPE_UI, "VERSION",\r
+                    BINARY_FILE_TYPE_PEI_DEPEX, BINARY_FILE_TYPE_GUID,\r
+                    BINARY_FILE_TYPE_SMM_DEPEX}:\r
+\r
+                if self._Token.startswith('PCD'):\r
+                    self._UndoToken()\r
+                    self._GetNextWord()\r
+\r
+                    if self._Token == 'PCD':\r
+                        if not self._IsToken("("):\r
+                            raise Warning.Expected("'('", self.FileName, self.CurrentLineNumber)\r
+                        PcdPair = self._GetNextPcdSettings()\r
+                        if not self._IsToken(")"):\r
+                            raise Warning.Expected("')'", self.FileName, self.CurrentLineNumber)\r
+                        self._Token = 'PCD('+PcdPair[1]+TAB_SPLIT+PcdPair[0]+')'\r
+\r
+                EfiSectionObj.FileName = self._Token\r
+\r

             else:\r
             else:\r

-                self.__UndoToken()\r
+                self._UndoToken()\r

         else:\r
         else:\r

-            raise Warning("expected section file name", self.FileName, self.CurrentLineNumber)\r
+            raise Warning.Expected("section file name", self.FileName, self.CurrentLineNumber)\r

 \r
         Obj.SectionList.append(EfiSectionObj)\r
         return True\r
 \r
 \r
         Obj.SectionList.append(EfiSectionObj)\r
         return True\r
 \r

-    ## __RuleSectionCouldBeOptional() method\r
+    ## _RuleSectionCouldBeOptional() method\r

     #\r
     #   Get whether a section could be optional\r
     #\r
     #\r
     #   Get whether a section could be optional\r
     #\r


@@ -3990,13 +3935,13 @@ class FdfParser:
     #   @retval False       section never optional\r
     #\r
     @staticmethod\r
     #   @retval False       section never optional\r
     #\r
     @staticmethod\r

-    def __RuleSectionCouldBeOptional(SectionType):\r
-        if SectionType in ("DXE_DEPEX", "UI", "VERSION", "PEI_DEPEX", "RAW", "SMM_DEPEX"):\r
+    def _RuleSectionCouldBeOptional(SectionType):\r
+        if SectionType in {BINARY_FILE_TYPE_DXE_DEPEX, BINARY_FILE_TYPE_UI, "VERSION", BINARY_FILE_TYPE_PEI_DEPEX, "RAW", BINARY_FILE_TYPE_SMM_DEPEX}:\r

             return True\r
         else:\r
             return False\r
 \r
             return True\r
         else:\r
             return False\r
 \r

-    ## __RuleSectionCouldHaveBuildNum() method\r
+    ## _RuleSectionCouldHaveBuildNum() method\r

     #\r
     #   Get whether a section could have build number information\r
     #\r
     #\r
     #   Get whether a section could have build number information\r
     #\r


@@ -4005,13 +3950,13 @@ class FdfParser:
     #   @retval False       section never have build number information\r
     #\r
     @staticmethod\r
     #   @retval False       section never have build number information\r
     #\r
     @staticmethod\r

-    def __RuleSectionCouldHaveBuildNum(SectionType):\r
-        if SectionType in ("VERSION"):\r
+    def _RuleSectionCouldHaveBuildNum(SectionType):\r
+        if SectionType == "VERSION":\r

             return True\r
         else:\r
             return False\r
 \r
             return True\r
         else:\r
             return False\r
 \r

-    ## __RuleSectionCouldHaveString() method\r
+    ## _RuleSectionCouldHaveString() method\r

     #\r
     #   Get whether a section could have string\r
     #\r
     #\r
     #   Get whether a section could have string\r
     #\r


@@ -4020,13 +3965,13 @@ class FdfParser:
     #   @retval False       section never have string\r
     #\r
     @staticmethod\r
     #   @retval False       section never have string\r
     #\r
     @staticmethod\r

-    def __RuleSectionCouldHaveString(SectionType):\r
-        if SectionType in ("UI", "VERSION"):\r
+    def _RuleSectionCouldHaveString(SectionType):\r
+        if SectionType in {BINARY_FILE_TYPE_UI, "VERSION"}:\r

             return True\r
         else:\r
             return False\r
 \r
             return True\r
         else:\r
             return False\r
 \r

-    ## __CheckRuleSectionFileType() method\r
+    ## _CheckRuleSectionFileType() method\r

     #\r
     #   Get whether a section matches a file type\r
     #\r
     #\r
     #   Get whether a section matches a file type\r
     #\r


@@ -4034,86 +3979,86 @@ class FdfParser:
     #   @param  SectionType The section type to check\r
     #   @param  FileType    The file type to check\r
     #\r
     #   @param  SectionType The section type to check\r
     #   @param  FileType    The file type to check\r
     #\r

-    def __CheckRuleSectionFileType(self, SectionType, FileType):\r
+    def _CheckRuleSectionFileType(self, SectionType, FileType):\r
+        WarningString = "Incorrect section file type '%s'"\r

         if SectionType == "COMPAT16":\r
         if SectionType == "COMPAT16":\r

-            if FileType not in ("COMPAT16", "SEC_COMPAT16"):\r
-                raise Warning("Incorrect section file type '%s'" % FileType, self.FileName, self.CurrentLineNumber)\r
-        elif SectionType == "PE32":\r
-            if FileType not in ("PE32", "SEC_PE32"):\r
-                raise Warning("Incorrect section file type '%s'" % FileType, self.FileName, self.CurrentLineNumber)\r
-        elif SectionType == "PIC":\r
-            if FileType not in ("PIC", "PIC"):\r
-                raise Warning("Incorrect section file type '%s'" % FileType, self.FileName, self.CurrentLineNumber)\r
-        elif SectionType == "TE":\r
-            if FileType not in ("TE", "SEC_TE"):\r
-                raise Warning("Incorrect section file type '%s'" % FileType, self.FileName, self.CurrentLineNumber)\r
+            if FileType not in {"COMPAT16", "SEC_COMPAT16"}:\r
+                raise Warning(WarningString % FileType, self.FileName, self.CurrentLineNumber)\r
+        elif SectionType == BINARY_FILE_TYPE_PE32:\r
+            if FileType not in {BINARY_FILE_TYPE_PE32, "SEC_PE32"}:\r
+                raise Warning(WarningString % FileType, self.FileName, self.CurrentLineNumber)\r
+        elif SectionType == BINARY_FILE_TYPE_PIC:\r
+            if FileType not in {BINARY_FILE_TYPE_PIC, BINARY_FILE_TYPE_PIC}:\r
+                raise Warning(WarningString % FileType, self.FileName, self.CurrentLineNumber)\r
+        elif SectionType == BINARY_FILE_TYPE_TE:\r
+            if FileType not in {BINARY_FILE_TYPE_TE, "SEC_TE"}:\r
+                raise Warning(WarningString % FileType, self.FileName, self.CurrentLineNumber)\r

         elif SectionType == "RAW":\r
         elif SectionType == "RAW":\r

-            if FileType not in ("BIN", "SEC_BIN", "RAW", "ASL", "ACPI"):\r
-                raise Warning("Incorrect section file type '%s'" % FileType, self.FileName, self.CurrentLineNumber)\r
-        elif SectionType == "DXE_DEPEX" or SectionType == "SMM_DEPEX":\r
-            if FileType not in ("DXE_DEPEX", "SEC_DXE_DEPEX", "SMM_DEPEX"):\r
-                raise Warning("Incorrect section file type '%s'" % FileType, self.FileName, self.CurrentLineNumber)\r
-        elif SectionType == "UI":\r
-            if FileType not in ("UI", "SEC_UI"):\r
-                raise Warning("Incorrect section file type '%s'" % FileType, self.FileName, self.CurrentLineNumber)\r
+            if FileType not in {BINARY_FILE_TYPE_BIN, "SEC_BIN", "RAW", "ASL", "ACPI"}:\r
+                raise Warning(WarningString % FileType, self.FileName, self.CurrentLineNumber)\r
+        elif SectionType == BINARY_FILE_TYPE_DXE_DEPEX or SectionType == BINARY_FILE_TYPE_SMM_DEPEX:\r
+            if FileType not in {BINARY_FILE_TYPE_DXE_DEPEX, "SEC_DXE_DEPEX", BINARY_FILE_TYPE_SMM_DEPEX}:\r
+                raise Warning(WarningString % FileType, self.FileName, self.CurrentLineNumber)\r
+        elif SectionType == BINARY_FILE_TYPE_UI:\r
+            if FileType not in {BINARY_FILE_TYPE_UI, "SEC_UI"}:\r
+                raise Warning(WarningString % FileType, self.FileName, self.CurrentLineNumber)\r

         elif SectionType == "VERSION":\r
         elif SectionType == "VERSION":\r

-            if FileType not in ("VERSION", "SEC_VERSION"):\r
-                raise Warning("Incorrect section file type '%s'" % FileType, self.FileName, self.CurrentLineNumber)\r
-        elif SectionType == "PEI_DEPEX":\r
-            if FileType not in ("PEI_DEPEX", "SEC_PEI_DEPEX"):\r
-                raise Warning("Incorrect section file type '%s'" % FileType, self.FileName, self.CurrentLineNumber)\r
-        elif SectionType == "GUID":\r
-            if FileType not in ("PE32", "SEC_GUID"):\r
-                raise Warning("Incorrect section file type '%s'" % FileType, self.FileName, self.CurrentLineNumber)\r
+            if FileType not in {"VERSION", "SEC_VERSION"}:\r
+                raise Warning(WarningString % FileType, self.FileName, self.CurrentLineNumber)\r
+        elif SectionType == BINARY_FILE_TYPE_PEI_DEPEX:\r
+            if FileType not in {BINARY_FILE_TYPE_PEI_DEPEX, "SEC_PEI_DEPEX"}:\r
+                raise Warning(WarningString % FileType, self.FileName, self.CurrentLineNumber)\r
+        elif SectionType == BINARY_FILE_TYPE_GUID:\r
+            if FileType not in {BINARY_FILE_TYPE_PE32, "SEC_GUID"}:\r
+                raise Warning(WarningString % FileType, self.FileName, self.CurrentLineNumber)\r

 \r
 \r

-    ## __GetRuleEncapsulationSection() method\r
+    ## _GetRuleEncapsulationSection() method\r

     #\r
     #   Get encapsulation section for Rule\r
     #\r
     #   @param  self        The object pointer\r
     #\r
     #   Get encapsulation section for Rule\r
     #\r
     #   @param  self        The object pointer\r

-    #   @param  Rule        for whom section is got\r
+    #   @param  theRule     for whom section is got\r

     #   @retval True        Successfully find section statement\r
     #   @retval False       Not able to find section statement\r
     #\r
     #   @retval True        Successfully find section statement\r
     #   @retval False       Not able to find section statement\r
     #\r

-    def __GetRuleEncapsulationSection(self, Rule):\r
-\r
-        if self.__IsKeyword( "COMPRESS"):\r
+    def _GetRuleEncapsulationSection(self, theRule):\r
+        if self._IsKeyword("COMPRESS"):\r

             Type = "PI_STD"\r
             Type = "PI_STD"\r

-            if self.__IsKeyword("PI_STD") or self.__IsKeyword("PI_NONE"):\r
-                Type = self.__Token\r
+            if self._IsKeyword("PI_STD") or self._IsKeyword("PI_NONE"):\r
+                Type = self._Token\r

 \r
 \r

-            if not self.__IsToken("{"):\r
-                raise Warning("expected '{'", self.FileName, self.CurrentLineNumber)\r
+            if not self._IsToken("{"):\r
+                raise Warning.ExpectedCurlyOpen(self.FileName, self.CurrentLineNumber)\r

 \r
 \r

-            CompressSectionObj = CompressSection.CompressSection()\r
+            CompressSectionObj = CompressSection()\r

 \r
             CompressSectionObj.CompType = Type\r
             # Recursive sections...\r
             while True:\r
 \r
             CompressSectionObj.CompType = Type\r
             # Recursive sections...\r
             while True:\r

-                IsEncapsulate = self.__GetRuleEncapsulationSection(CompressSectionObj)\r
-                IsLeaf = self.__GetEfiSection(CompressSectionObj)\r
+                IsEncapsulate = self._GetRuleEncapsulationSection(CompressSectionObj)\r
+                IsLeaf = self._GetEfiSection(CompressSectionObj)\r

                 if not IsEncapsulate and not IsLeaf:\r
                     break\r
 \r
                 if not IsEncapsulate and not IsLeaf:\r
                     break\r
 \r

-            if not self.__IsToken( "}"):\r
-                raise Warning("expected '}'", self.FileName, self.CurrentLineNumber)\r
-            Rule.SectionList.append(CompressSectionObj)\r
+            if not self._IsToken(T_CHAR_BRACE_R):\r
+                raise Warning.ExpectedCurlyClose(self.FileName, self.CurrentLineNumber)\r
+            theRule.SectionList.append(CompressSectionObj)\r

 \r
             return True\r
 \r
 \r
             return True\r
 \r

-        elif self.__IsKeyword( "GUIDED"):\r
+        elif self._IsKeyword("GUIDED"):\r

             GuidValue = None\r
             GuidValue = None\r

-            if self.__GetNextGuid():\r
-                GuidValue = self.__Token\r
+            if self._GetNextGuid():\r
+                GuidValue = self._Token\r

 \r
 \r

-            if self.__IsKeyword( "$(NAMED_GUID)"):\r
-                GuidValue = self.__Token\r
+            if self._IsKeyword("$(NAMED_GUID)"):\r
+                GuidValue = self._Token\r

 \r
 \r

-            AttribDict = self.__GetGuidAttrib()\r
+            AttribDict = self._GetGuidAttrib()\r

 \r
 \r

-            if not self.__IsToken("{"):\r
-                raise Warning("expected '{'", self.FileName, self.CurrentLineNumber)\r
-            GuidSectionObj = GuidSection.GuidSection()\r
+            if not self._IsToken("{"):\r
+                raise Warning.ExpectedCurlyOpen(self.FileName, self.CurrentLineNumber)\r
+            GuidSectionObj = GuidSection()\r

             GuidSectionObj.NameGuid = GuidValue\r
             GuidSectionObj.SectionType = "GUIDED"\r
             GuidSectionObj.ProcessRequired = AttribDict["PROCESSING_REQUIRED"]\r
             GuidSectionObj.NameGuid = GuidValue\r
             GuidSectionObj.SectionType = "GUIDED"\r
             GuidSectionObj.ProcessRequired = AttribDict["PROCESSING_REQUIRED"]\r


@@ -4122,226 +4067,20 @@ class FdfParser:
 \r
             # Efi sections...\r
             while True:\r
 \r
             # Efi sections...\r
             while True:\r

-                IsEncapsulate = self.__GetRuleEncapsulationSection(GuidSectionObj)\r
-                IsLeaf = self.__GetEfiSection(GuidSectionObj)\r
+                IsEncapsulate = self._GetRuleEncapsulationSection(GuidSectionObj)\r
+                IsLeaf = self._GetEfiSection(GuidSectionObj)\r

                 if not IsEncapsulate and not IsLeaf:\r
                     break\r
 \r
                 if not IsEncapsulate and not IsLeaf:\r
                     break\r
 \r

-            if not self.__IsToken( "}"):\r
-                raise Warning("expected '}'", self.FileName, self.CurrentLineNumber)\r
-            Rule.SectionList.append(GuidSectionObj)\r
+            if not self._IsToken(T_CHAR_BRACE_R):\r
+                raise Warning.ExpectedCurlyClose(self.FileName, self.CurrentLineNumber)\r
+            theRule.SectionList.append(GuidSectionObj)\r

 \r
             return True\r
 \r
         return False\r
 \r
 \r
             return True\r
 \r
         return False\r
 \r

-    ## __GetVtf() method\r
-    #\r
-    #   Get VTF section contents and store its data into VTF list of self.Profile\r
-    #\r
-    #   @param  self        The object pointer\r
-    #   @retval True        Successfully find a VTF\r
-    #   @retval False       Not able to find a VTF\r
-    #\r
-    def __GetVtf(self):\r
-\r
-        if not self.__GetNextToken():\r
-            return False\r
-\r
-        S = self.__Token.upper()\r
-        if S.startswith("[") and not S.startswith("[VTF."):\r
-            self.SectionParser(S)\r
-            self.__UndoToken()\r
-            return False\r
-\r
-        self.__UndoToken()\r
-        if not self.__IsToken("[VTF.", True):\r
-            FileLineTuple = GetRealFileLine(self.FileName, self.CurrentLineNumber)\r
-            #print 'Parsing String: %s in File %s, At line: %d, Offset Within Line: %d' \\r
-            #        % (self.Profile.FileLinesList[self.CurrentLineNumber - 1][self.CurrentOffsetWithinLine :], FileLineTuple[0], FileLineTuple[1], self.CurrentOffsetWithinLine)\r
-            raise Warning("expected [VTF.]", self.FileName, self.CurrentLineNumber)\r
-\r
-        if not self.__SkipToToken("."):\r
-            raise Warning("expected '.'", self.FileName, self.CurrentLineNumber)\r
-\r
-        Arch = self.__SkippedChars.rstrip(".").upper()\r
-        if Arch not in ("IA32", "X64", "IPF", "ARM", "AARCH64"):\r
-            raise Warning("Unknown Arch '%s'" % Arch, self.FileName, self.CurrentLineNumber)\r
-\r
-        if not self.__GetNextWord():\r
-            raise Warning("expected VTF name", self.FileName, self.CurrentLineNumber)\r
-        Name = self.__Token.upper()\r
-\r
-        VtfObj = Vtf.Vtf()\r
-        VtfObj.UiName = Name\r
-        VtfObj.KeyArch = Arch\r
-\r
-        if self.__IsToken(","):\r
-            if not self.__GetNextWord():\r
-                raise Warning("expected Arch list", self.FileName, self.CurrentLineNumber)\r
-            if self.__Token.upper() not in ("IA32", "X64", "IPF", "ARM", "AARCH64"):\r
-                raise Warning("Unknown Arch '%s'" % self.__Token, self.FileName, self.CurrentLineNumber)\r
-            VtfObj.ArchList = self.__Token.upper()\r
-\r
-        if not self.__IsToken( "]"):\r
-            raise Warning("expected ']'", self.FileName, self.CurrentLineNumber)\r
-\r
-        if self.__IsKeyword("IA32_RST_BIN"):\r
-            if not self.__IsToken("="):\r
-                raise Warning("expected '='", self.FileName, self.CurrentLineNumber)\r
-\r
-            if not self.__GetNextToken():\r
-                raise Warning("expected Reset file", self.FileName, self.CurrentLineNumber)\r
-\r
-            VtfObj.ResetBin = self.__Token\r
-            if VtfObj.ResetBin.replace('$(WORKSPACE)', '').find('$') == -1:\r
-                #check for file path\r
-                ErrorCode, ErrorInfo = PathClass(NormPath(VtfObj.ResetBin), GenFdsGlobalVariable.WorkSpaceDir).Validate()\r
-                if ErrorCode != 0:\r
-                    EdkLogger.error("GenFds", ErrorCode, ExtraData=ErrorInfo)\r
-\r
-        while self.__GetComponentStatement(VtfObj):\r
-            pass\r
-\r
-        self.Profile.VtfList.append(VtfObj)\r
-        return True\r
-\r
-    ## __GetComponentStatement() method\r
-    #\r
-    #   Get components in VTF\r
-    #\r
-    #   @param  self        The object pointer\r
-    #   @param  VtfObj         for whom component is got\r
-    #   @retval True        Successfully find a component\r
-    #   @retval False       Not able to find a component\r
-    #\r
-    def __GetComponentStatement(self, VtfObj):\r
-\r
-        if not self.__IsKeyword("COMP_NAME"):\r
-            return False\r
-\r
-        if not self.__IsToken("="):\r
-            raise Warning("expected '='", self.FileName, self.CurrentLineNumber)\r
-\r
-        if not self.__GetNextWord():\r
-            raise Warning("expected Component Name", self.FileName, self.CurrentLineNumber)\r
-\r
-        CompStatementObj = ComponentStatement.ComponentStatement()\r
-        CompStatementObj.CompName = self.__Token\r
-\r
-        if not self.__IsKeyword("COMP_LOC"):\r
-            raise Warning("expected COMP_LOC", self.FileName, self.CurrentLineNumber)\r
-\r
-        if not self.__IsToken("="):\r
-            raise Warning("expected '='", self.FileName, self.CurrentLineNumber)\r
-\r
-        CompStatementObj.CompLoc = ""\r
-        if self.__GetNextWord():\r
-            CompStatementObj.CompLoc = self.__Token\r
-            if self.__IsToken('|'):\r
-                if not self.__GetNextWord():\r
-                    raise Warning("Expected Region Name", self.FileName, self.CurrentLineNumber)\r
-\r
-                if self.__Token not in ("F", "N", "S"):    #, "H", "L", "PH", "PL"): not support\r
-                    raise Warning("Unknown location type '%s'" % self.__Token, self.FileName, self.CurrentLineNumber)\r
-\r
-                CompStatementObj.FilePos = self.__Token\r
-        else:\r
-            self.CurrentLineNumber += 1\r
-            self.CurrentOffsetWithinLine = 0\r
-\r
-        if not self.__IsKeyword("COMP_TYPE"):\r
-            raise Warning("expected COMP_TYPE", self.FileName, self.CurrentLineNumber)\r
-\r
-        if not self.__IsToken("="):\r
-            raise Warning("expected '='", self.FileName, self.CurrentLineNumber)\r
-\r
-        if not self.__GetNextToken():\r
-            raise Warning("expected Component type", self.FileName, self.CurrentLineNumber)\r
-        if self.__Token not in ("FIT", "PAL_B", "PAL_A", "OEM"):\r
-            if not self.__Token.startswith("0x") or len(self.__Token) < 3 or len(self.__Token) > 4 or \\r
-                not self.__Token[2] in string.hexdigits or not self.__Token[-1] in string.hexdigits:\r
-                raise Warning("Unknown location type '%s'" % self.__Token, self.FileName, self.CurrentLineNumber)\r
-        CompStatementObj.CompType = self.__Token\r
-\r
-        if not self.__IsKeyword("COMP_VER"):\r
-            raise Warning("expected COMP_VER", self.FileName, self.CurrentLineNumber)\r
-\r
-        if not self.__IsToken("="):\r
-            raise Warning("expected '='", self.FileName, self.CurrentLineNumber)\r
-\r
-        if not self.__GetNextToken():\r
-            raise Warning("expected Component version", self.FileName, self.CurrentLineNumber)\r
-\r
-        Pattern = re.compile('-$|[0-9a-fA-F]{1,2}\.[0-9a-fA-F]{1,2}$', re.DOTALL)\r
-        if Pattern.match(self.__Token) is None:\r
-            raise Warning("Unknown version format '%s'" % self.__Token, self.FileName, self.CurrentLineNumber)\r
-        CompStatementObj.CompVer = self.__Token\r
-\r
-        if not self.__IsKeyword("COMP_CS"):\r
-            raise Warning("expected COMP_CS", self.FileName, self.CurrentLineNumber)\r
-\r
-        if not self.__IsToken("="):\r
-            raise Warning("expected '='", self.FileName, self.CurrentLineNumber)\r
-\r
-        if not self.__GetNextToken():\r
-            raise Warning("expected Component CS", self.FileName, self.CurrentLineNumber)\r
-        if self.__Token not in ("1", "0"):\r
-            raise Warning("Unknown  Component CS '%s'" % self.__Token, self.FileName, self.CurrentLineNumber)\r
-        CompStatementObj.CompCs = self.__Token\r
-\r
-\r
-        if not self.__IsKeyword("COMP_BIN"):\r
-            raise Warning("expected COMP_BIN", self.FileName, self.CurrentLineNumber)\r
-\r
-        if not self.__IsToken("="):\r
-            raise Warning("expected '='", self.FileName, self.CurrentLineNumber)\r
-\r
-        if not self.__GetNextToken():\r
-            raise Warning("expected Component file", self.FileName, self.CurrentLineNumber)\r
-\r
-        CompStatementObj.CompBin = self.__Token\r
-        if CompStatementObj.CompBin != '-' and CompStatementObj.CompBin.replace('$(WORKSPACE)', '').find('$') == -1:\r
-            #check for file path\r
-            ErrorCode, ErrorInfo = PathClass(NormPath(CompStatementObj.CompBin), GenFdsGlobalVariable.WorkSpaceDir).Validate()\r
-            if ErrorCode != 0:\r
-                EdkLogger.error("GenFds", ErrorCode, ExtraData=ErrorInfo)\r
-\r
-        if not self.__IsKeyword("COMP_SYM"):\r
-            raise Warning("expected COMP_SYM", self.FileName, self.CurrentLineNumber)\r
-\r
-        if not self.__IsToken("="):\r
-            raise Warning("expected '='", self.FileName, self.CurrentLineNumber)\r
-\r
-        if not self.__GetNextToken():\r
-            raise Warning("expected Component symbol file", self.FileName, self.CurrentLineNumber)\r
-\r
-        CompStatementObj.CompSym = self.__Token\r
-        if CompStatementObj.CompSym != '-' and CompStatementObj.CompSym.replace('$(WORKSPACE)', '').find('$') == -1:\r
-            #check for file path\r
-            ErrorCode, ErrorInfo = PathClass(NormPath(CompStatementObj.CompSym), GenFdsGlobalVariable.WorkSpaceDir).Validate()\r
-            if ErrorCode != 0:\r
-                EdkLogger.error("GenFds", ErrorCode, ExtraData=ErrorInfo)\r
-\r
-        if not self.__IsKeyword("COMP_SIZE"):\r
-            raise Warning("expected COMP_SIZE", self.FileName, self.CurrentLineNumber)\r
-\r
-        if not self.__IsToken("="):\r
-            raise Warning("expected '='", self.FileName, self.CurrentLineNumber)\r
-\r
-        if self.__IsToken("-"):\r
-            CompStatementObj.CompSize = self.__Token\r
-        elif self.__GetNextDecimalNumber():\r
-            CompStatementObj.CompSize = self.__Token\r
-        elif self.__GetNextHexNumber():\r
-            CompStatementObj.CompSize = self.__Token\r
-        else:\r
-            raise Warning("Unknown size '%s'" % self.__Token, self.FileName, self.CurrentLineNumber)\r
-\r
-        VtfObj.ComponentStatementList.append(CompStatementObj)\r
-        return True\r
-\r
-    ## __GetOptionRom() method\r
+    ## _GetOptionRom() method\r

     #\r
     #   Get OptionROM section contents and store its data into OptionROM list of self.Profile\r
     #\r
     #\r
     #   Get OptionROM section contents and store its data into OptionROM list of self.Profile\r
     #\r


@@ -4349,39 +4088,37 @@ class FdfParser:
     #   @retval True        Successfully find a OptionROM\r
     #   @retval False       Not able to find a OptionROM\r
     #\r
     #   @retval True        Successfully find a OptionROM\r
     #   @retval False       Not able to find a OptionROM\r
     #\r

-    def __GetOptionRom(self):\r
-\r
-        if not self.__GetNextToken():\r
+    def _GetOptionRom(self):\r
+        if not self._GetNextToken():\r

             return False\r
 \r
             return False\r
 \r

-        S = self.__Token.upper()\r
-        if S.startswith("[") and not S.startswith("[OPTIONROM."):\r
+        S = self._Token.upper()\r
+        if S.startswith(TAB_SECTION_START) and not S.startswith("[OPTIONROM."):\r

             self.SectionParser(S)\r
             self.SectionParser(S)\r

-            self.__UndoToken()\r
+            self._UndoToken()\r

             return False\r
             return False\r

-        \r
-        self.__UndoToken()\r
-        if not self.__IsToken("[OptionRom.", True):\r
-            raise Warning("Unknown Keyword '%s'" % self.__Token, self.FileName, self.CurrentLineNumber)\r

 \r
 \r

-        OptRomName = self.__GetUiName()\r
+        self._UndoToken()\r
+        if not self._IsToken("[OptionRom.", True):\r
+            raise Warning("Unknown Keyword '%s'" % self._Token, self.FileName, self.CurrentLineNumber)\r
+\r
+        OptRomName = self._GetUiName()\r

 \r
 \r

-        if not self.__IsToken( "]"):\r
-            raise Warning("expected ']'", self.FileName, self.CurrentLineNumber)\r
+        if not self._IsToken(TAB_SECTION_END):\r
+            raise Warning.ExpectedBracketClose(self.FileName, self.CurrentLineNumber)\r

 \r
 \r

-        OptRomObj = OptionRom.OPTIONROM()\r
-        OptRomObj.DriverName = OptRomName\r
+        OptRomObj = OPTIONROM(OptRomName)\r

         self.Profile.OptRomDict[OptRomName] = OptRomObj\r
 \r
         while True:\r
         self.Profile.OptRomDict[OptRomName] = OptRomObj\r
 \r
         while True:\r

-            isInf = self.__GetOptRomInfStatement(OptRomObj)\r
-            isFile = self.__GetOptRomFileStatement(OptRomObj)\r
+            isInf = self._GetOptRomInfStatement(OptRomObj)\r
+            isFile = self._GetOptRomFileStatement(OptRomObj)\r

             if not isInf and not isFile:\r
                 break\r
             if not isInf and not isFile:\r
                 break\r

-            \r
+\r

         return True\r
 \r
         return True\r
 \r

-    ## __GetOptRomInfStatement() method\r
+    ## _GetOptRomInfStatement() method\r

     #\r
     #   Get INF statements\r
     #\r
     #\r
     #   Get INF statements\r
     #\r


@@ -4390,25 +4127,28 @@ class FdfParser:
     #   @retval True        Successfully find inf statement\r
     #   @retval False       Not able to find inf statement\r
     #\r
     #   @retval True        Successfully find inf statement\r
     #   @retval False       Not able to find inf statement\r
     #\r

-    def __GetOptRomInfStatement(self, Obj):\r
-\r
-        if not self.__IsKeyword( "INF"):\r
+    def _GetOptRomInfStatement(self, Obj):\r
+        if not self._IsKeyword("INF"):\r

             return False\r
 \r
             return False\r
 \r

-        ffsInf = OptRomInfStatement.OptRomInfStatement()\r
-        self.__GetInfOptions( ffsInf)\r
+        ffsInf = OptRomInfStatement()\r
+        self._GetInfOptions(ffsInf)\r

 \r
 \r

-        if not self.__GetNextToken():\r
-            raise Warning("expected INF file path", self.FileName, self.CurrentLineNumber)\r
-        ffsInf.InfFileName = self.__Token\r
-        if ffsInf.InfFileName.replace('$(WORKSPACE)', '').find('$') == -1:\r
+        if not self._GetNextToken():\r
+            raise Warning.Expected("INF file path", self.FileName, self.CurrentLineNumber)\r
+        ffsInf.InfFileName = self._Token\r
+        if ffsInf.InfFileName.replace(TAB_WORKSPACE, '').find('$') == -1:\r

             #check for file path\r
             ErrorCode, ErrorInfo = PathClass(NormPath(ffsInf.InfFileName), GenFdsGlobalVariable.WorkSpaceDir).Validate()\r
             if ErrorCode != 0:\r
                 EdkLogger.error("GenFds", ErrorCode, ExtraData=ErrorInfo)\r
 \r
             #check for file path\r
             ErrorCode, ErrorInfo = PathClass(NormPath(ffsInf.InfFileName), GenFdsGlobalVariable.WorkSpaceDir).Validate()\r
             if ErrorCode != 0:\r
                 EdkLogger.error("GenFds", ErrorCode, ExtraData=ErrorInfo)\r
 \r

-        if not ffsInf.InfFileName in self.Profile.InfList:\r
-            self.Profile.InfList.append(ffsInf.InfFileName)\r
+        NewFileName = ffsInf.InfFileName\r
+        if ffsInf.OverrideGuid:\r
+            NewFileName = ProcessDuplicatedInf(PathClass(ffsInf.InfFileName,GenFdsGlobalVariable.WorkSpaceDir), ffsInf.OverrideGuid, GenFdsGlobalVariable.WorkSpaceDir).Path\r
+\r
+        if not NewFileName in self.Profile.InfList:\r
+            self.Profile.InfList.append(NewFileName)\r

             FileLineTuple = GetRealFileLine(self.FileName, self.CurrentLineNumber)\r
             self.Profile.InfFileLineList.append(FileLineTuple)\r
             if ffsInf.UseArch:\r
             FileLineTuple = GetRealFileLine(self.FileName, self.CurrentLineNumber)\r
             self.Profile.InfFileLineList.append(FileLineTuple)\r
             if ffsInf.UseArch:\r


@@ -4419,72 +4159,74 @@ class FdfParser:
             else:\r
                 self.Profile.InfDict['ArchTBD'].append(ffsInf.InfFileName)\r
 \r
             else:\r
                 self.Profile.InfDict['ArchTBD'].append(ffsInf.InfFileName)\r
 \r

-        \r
-        self.__GetOptRomOverrides (ffsInf)\r
-            \r
+\r
+        self._GetOptRomOverrides (ffsInf)\r
+\r

         Obj.FfsList.append(ffsInf)\r
         return True\r
 \r
         Obj.FfsList.append(ffsInf)\r
         return True\r
 \r

-    ## __GetOptRomOverrides() method\r
+    ## _GetOptRomOverrides() method\r

     #\r
     #   Get overrides for OptROM INF & FILE\r
     #\r
     #   @param  self        The object pointer\r
     #   @param  FfsInfObj   for whom overrides is got\r
     #\r
     #\r
     #   Get overrides for OptROM INF & FILE\r
     #\r
     #   @param  self        The object pointer\r
     #   @param  FfsInfObj   for whom overrides is got\r
     #\r

-    def __GetOptRomOverrides(self, Obj):\r
-        if self.__IsToken('{'):\r
-            Overrides = OptionRom.OverrideAttribs()\r
+    def _GetOptRomOverrides(self, Obj):\r
+        if self._IsToken('{'):\r
+            Overrides = OverrideAttribs()\r

             while True:\r
             while True:\r

-                if self.__IsKeyword( "PCI_VENDOR_ID"):\r
-                    if not self.__IsToken( "="):\r
-                        raise Warning("expected '='", self.FileName, self.CurrentLineNumber)\r
-                    if not self.__GetNextHexNumber():\r
-                        raise Warning("expected Hex vendor id", self.FileName, self.CurrentLineNumber)\r
-                    Overrides.PciVendorId = self.__Token\r
+                if self._IsKeyword("PCI_VENDOR_ID"):\r
+                    if not self._IsToken(TAB_EQUAL_SPLIT):\r
+                        raise Warning.ExpectedEquals(self.FileName, self.CurrentLineNumber)\r
+                    if not self._GetNextHexNumber():\r
+                        raise Warning.Expected("Hex vendor id", self.FileName, self.CurrentLineNumber)\r
+                    Overrides.PciVendorId = self._Token\r

                     continue\r
 \r
                     continue\r
 \r

-                if self.__IsKeyword( "PCI_CLASS_CODE"):\r
-                    if not self.__IsToken( "="):\r
-                        raise Warning("expected '='", self.FileName, self.CurrentLineNumber)\r
-                    if not self.__GetNextHexNumber():\r
-                        raise Warning("expected Hex class code", self.FileName, self.CurrentLineNumber)\r
-                    Overrides.PciClassCode = self.__Token\r
+                if self._IsKeyword("PCI_CLASS_CODE"):\r
+                    if not self._IsToken(TAB_EQUAL_SPLIT):\r
+                        raise Warning.ExpectedEquals(self.FileName, self.CurrentLineNumber)\r
+                    if not self._GetNextHexNumber():\r
+                        raise Warning.Expected("Hex class code", self.FileName, self.CurrentLineNumber)\r
+                    Overrides.PciClassCode = self._Token\r

                     continue\r
 \r
                     continue\r
 \r

-                if self.__IsKeyword( "PCI_DEVICE_ID"):\r
-                    if not self.__IsToken( "="):\r
-                        raise Warning("expected '='", self.FileName, self.CurrentLineNumber)\r
-                    if not self.__GetNextHexNumber():\r
-                        raise Warning("expected Hex device id", self.FileName, self.CurrentLineNumber)\r
-\r
-                    Overrides.PciDeviceId = self.__Token\r
+                if self._IsKeyword("PCI_DEVICE_ID"):\r
+                    if not self._IsToken(TAB_EQUAL_SPLIT):\r
+                        raise Warning.ExpectedEquals(self.FileName, self.CurrentLineNumber)\r
+                    # Get a list of PCI IDs\r
+                    Overrides.PciDeviceId = ""\r
+                    while (self._GetNextHexNumber()):\r
+                        Overrides.PciDeviceId = "{} {}".format(Overrides.PciDeviceId, self._Token)\r
+                    if not Overrides.PciDeviceId:\r
+                        raise Warning.Expected("one or more Hex device ids", self.FileName, self.CurrentLineNumber)\r

                     continue\r
 \r
                     continue\r
 \r

-                if self.__IsKeyword( "PCI_REVISION"):\r
-                    if not self.__IsToken( "="):\r
-                        raise Warning("expected '='", self.FileName, self.CurrentLineNumber)\r
-                    if not self.__GetNextHexNumber():\r
-                        raise Warning("expected Hex revision", self.FileName, self.CurrentLineNumber)\r
-                    Overrides.PciRevision = self.__Token\r
+                if self._IsKeyword("PCI_REVISION"):\r
+                    if not self._IsToken(TAB_EQUAL_SPLIT):\r
+                        raise Warning.ExpectedEquals(self.FileName, self.CurrentLineNumber)\r
+                    if not self._GetNextHexNumber():\r
+                        raise Warning.Expected("Hex revision", self.FileName, self.CurrentLineNumber)\r
+                    Overrides.PciRevision = self._Token\r

                     continue\r
 \r
                     continue\r
 \r

-                if self.__IsKeyword( "PCI_COMPRESS"):\r
-                    if not self.__IsToken( "="):\r
-                        raise Warning("expected '='", self.FileName, self.CurrentLineNumber)\r
-                    if not self.__GetNextToken():\r
-                        raise Warning("expected TRUE/FALSE for compress", self.FileName, self.CurrentLineNumber)\r
-                    Overrides.NeedCompress = self.__Token.upper() == 'TRUE'\r
+                if self._IsKeyword("PCI_COMPRESS"):\r
+                    if not self._IsToken(TAB_EQUAL_SPLIT):\r
+                        raise Warning.ExpectedEquals(self.FileName, self.CurrentLineNumber)\r
+                    if not self._GetNextToken():\r
+                        raise Warning.Expected("TRUE/FALSE for compress", self.FileName, self.CurrentLineNumber)\r
+                    Overrides.NeedCompress = self._Token.upper() == 'TRUE'\r

                     continue\r
 \r
                     continue\r
 \r

-                if self.__IsToken( "}"):\r
+                if self._IsToken(T_CHAR_BRACE_R):\r

                     break\r
                 else:\r
                     EdkLogger.error("FdfParser", FORMAT_INVALID, File=self.FileName, Line=self.CurrentLineNumber)\r
 \r
             Obj.OverrideAttribs = Overrides\r
                     break\r
                 else:\r
                     EdkLogger.error("FdfParser", FORMAT_INVALID, File=self.FileName, Line=self.CurrentLineNumber)\r
 \r
             Obj.OverrideAttribs = Overrides\r

-            \r
-    ## __GetOptRomFileStatement() method\r
+\r
+    ## _GetOptRomFileStatement() method\r

     #\r
     #   Get FILE statements\r
     #\r
     #\r
     #   Get FILE statements\r
     #\r


@@ -4493,34 +4235,33 @@ class FdfParser:
     #   @retval True        Successfully find FILE statement\r
     #   @retval False       Not able to find FILE statement\r
     #\r
     #   @retval True        Successfully find FILE statement\r
     #   @retval False       Not able to find FILE statement\r
     #\r

-    def __GetOptRomFileStatement(self, Obj):\r
-\r
-        if not self.__IsKeyword( "FILE"):\r
+    def _GetOptRomFileStatement(self, Obj):\r
+        if not self._IsKeyword("FILE"):\r

             return False\r
 \r
             return False\r
 \r

-        FfsFileObj = OptRomFileStatement.OptRomFileStatement()\r
+        FfsFileObj = OptRomFileStatement()\r

 \r
 \r

-        if not self.__IsKeyword("EFI") and not self.__IsKeyword("BIN"):\r
-            raise Warning("expected Binary type (EFI/BIN)", self.FileName, self.CurrentLineNumber)\r
-        FfsFileObj.FileType = self.__Token\r
+        if not self._IsKeyword("EFI") and not self._IsKeyword(BINARY_FILE_TYPE_BIN):\r
+            raise Warning.Expected("Binary type (EFI/BIN)", self.FileName, self.CurrentLineNumber)\r
+        FfsFileObj.FileType = self._Token\r

 \r
 \r

-        if not self.__GetNextToken():\r
-            raise Warning("expected File path", self.FileName, self.CurrentLineNumber)\r
-        FfsFileObj.FileName = self.__Token\r
-        if FfsFileObj.FileName.replace('$(WORKSPACE)', '').find('$') == -1:\r
+        if not self._GetNextToken():\r
+            raise Warning.Expected("File path", self.FileName, self.CurrentLineNumber)\r
+        FfsFileObj.FileName = self._Token\r
+        if FfsFileObj.FileName.replace(TAB_WORKSPACE, '').find('$') == -1:\r

             #check for file path\r
             ErrorCode, ErrorInfo = PathClass(NormPath(FfsFileObj.FileName), GenFdsGlobalVariable.WorkSpaceDir).Validate()\r
             if ErrorCode != 0:\r
                 EdkLogger.error("GenFds", ErrorCode, ExtraData=ErrorInfo)\r
 \r
         if FfsFileObj.FileType == 'EFI':\r
             #check for file path\r
             ErrorCode, ErrorInfo = PathClass(NormPath(FfsFileObj.FileName), GenFdsGlobalVariable.WorkSpaceDir).Validate()\r
             if ErrorCode != 0:\r
                 EdkLogger.error("GenFds", ErrorCode, ExtraData=ErrorInfo)\r
 \r
         if FfsFileObj.FileType == 'EFI':\r

-            self.__GetOptRomOverrides(FfsFileObj)\r
-        \r
+            self._GetOptRomOverrides(FfsFileObj)\r
+\r

         Obj.FfsList.append(FfsFileObj)\r
 \r
         return True\r
 \r
         Obj.FfsList.append(FfsFileObj)\r
 \r
         return True\r
 \r

-    ## __GetCapInFd() method\r
+    ## _GetCapInFd() method\r

     #\r
     #   Get Cap list contained in FD\r
     #\r
     #\r
     #   Get Cap list contained in FD\r
     #\r


@@ -4528,10 +4269,9 @@ class FdfParser:
     #   @param  FdName      FD name\r
     #   @retval CapList     List of Capsule in FD\r
     #\r
     #   @param  FdName      FD name\r
     #   @retval CapList     List of Capsule in FD\r
     #\r

-    def __GetCapInFd (self, FdName):\r
-\r
+    def _GetCapInFd (self, FdName):\r

         CapList = []\r
         CapList = []\r

-        if FdName.upper() in self.Profile.FdDict.keys():\r
+        if FdName.upper() in self.Profile.FdDict:\r

             FdObj = self.Profile.FdDict[FdName.upper()]\r
             for elementRegion in FdObj.RegionList:\r
                 if elementRegion.RegionType == 'CAPSULE':\r
             FdObj = self.Profile.FdDict[FdName.upper()]\r
             for elementRegion in FdObj.RegionList:\r
                 if elementRegion.RegionType == 'CAPSULE':\r


@@ -4542,7 +4282,7 @@ class FdfParser:
                             CapList.append(elementRegionData.upper())\r
         return CapList\r
 \r
                             CapList.append(elementRegionData.upper())\r
         return CapList\r
 \r

-    ## __GetReferencedFdCapTuple() method\r
+    ## _GetReferencedFdCapTuple() method\r

     #\r
     #   Get FV and FD list referenced by a capsule image\r
     #\r
     #\r
     #   Get FV and FD list referenced by a capsule image\r
     #\r


@@ -4551,23 +4291,22 @@ class FdfParser:
     #   @param  RefFdList   referenced FD by section\r
     #   @param  RefFvList   referenced FV by section\r
     #\r
     #   @param  RefFdList   referenced FD by section\r
     #   @param  RefFvList   referenced FV by section\r
     #\r

-    def __GetReferencedFdCapTuple(self, CapObj, RefFdList = [], RefFvList = []):\r
-\r
-        for CapsuleDataObj in CapObj.CapsuleDataList :\r
+    def _GetReferencedFdCapTuple(self, CapObj, RefFdList = [], RefFvList = []):\r
+        for CapsuleDataObj in CapObj.CapsuleDataList:\r

             if hasattr(CapsuleDataObj, 'FvName') and CapsuleDataObj.FvName is not None and CapsuleDataObj.FvName.upper() not in RefFvList:\r
                 RefFvList.append (CapsuleDataObj.FvName.upper())\r
             elif hasattr(CapsuleDataObj, 'FdName') and CapsuleDataObj.FdName is not None and CapsuleDataObj.FdName.upper() not in RefFdList:\r
             if hasattr(CapsuleDataObj, 'FvName') and CapsuleDataObj.FvName is not None and CapsuleDataObj.FvName.upper() not in RefFvList:\r
                 RefFvList.append (CapsuleDataObj.FvName.upper())\r
             elif hasattr(CapsuleDataObj, 'FdName') and CapsuleDataObj.FdName is not None and CapsuleDataObj.FdName.upper() not in RefFdList:\r

-                RefFdList.append (CapsuleDataObj.FdName.upper())            \r
+                RefFdList.append (CapsuleDataObj.FdName.upper())\r

             elif CapsuleDataObj.Ffs is not None:\r
             elif CapsuleDataObj.Ffs is not None:\r

-                if isinstance(CapsuleDataObj.Ffs, FfsFileStatement.FileStatement):\r
+                if isinstance(CapsuleDataObj.Ffs, FileStatement):\r

                     if CapsuleDataObj.Ffs.FvName is not None and CapsuleDataObj.Ffs.FvName.upper() not in RefFvList:\r
                         RefFvList.append(CapsuleDataObj.Ffs.FvName.upper())\r
                     elif CapsuleDataObj.Ffs.FdName is not None and CapsuleDataObj.Ffs.FdName.upper() not in RefFdList:\r
                         RefFdList.append(CapsuleDataObj.Ffs.FdName.upper())\r
                     else:\r
                     if CapsuleDataObj.Ffs.FvName is not None and CapsuleDataObj.Ffs.FvName.upper() not in RefFvList:\r
                         RefFvList.append(CapsuleDataObj.Ffs.FvName.upper())\r
                     elif CapsuleDataObj.Ffs.FdName is not None and CapsuleDataObj.Ffs.FdName.upper() not in RefFdList:\r
                         RefFdList.append(CapsuleDataObj.Ffs.FdName.upper())\r
                     else:\r

-                        self.__GetReferencedFdFvTupleFromSection(CapsuleDataObj.Ffs, RefFdList, RefFvList)\r
+                        self._GetReferencedFdFvTupleFromSection(CapsuleDataObj.Ffs, RefFdList, RefFvList)\r

 \r
 \r

-    ## __GetFvInFd() method\r
+    ## _GetFvInFd() method\r

     #\r
     #   Get FV list contained in FD\r
     #\r
     #\r
     #   Get FV list contained in FD\r
     #\r


@@ -4575,13 +4314,12 @@ class FdfParser:
     #   @param  FdName      FD name\r
     #   @retval FvList      list of FV in FD\r
     #\r
     #   @param  FdName      FD name\r
     #   @retval FvList      list of FV in FD\r
     #\r

-    def __GetFvInFd (self, FdName):\r
-\r
+    def _GetFvInFd (self, FdName):\r

         FvList = []\r
         FvList = []\r

-        if FdName.upper() in self.Profile.FdDict.keys():\r
+        if FdName.upper() in self.Profile.FdDict:\r

             FdObj = self.Profile.FdDict[FdName.upper()]\r
             for elementRegion in FdObj.RegionList:\r
             FdObj = self.Profile.FdDict[FdName.upper()]\r
             for elementRegion in FdObj.RegionList:\r

-                if elementRegion.RegionType == 'FV':\r
+                if elementRegion.RegionType == BINARY_FILE_TYPE_FV:\r

                     for elementRegionData in elementRegion.RegionDataList:\r
                         if elementRegionData.endswith(".fv"):\r
                             continue\r
                     for elementRegionData in elementRegion.RegionDataList:\r
                         if elementRegionData.endswith(".fv"):\r
                             continue\r


@@ -4589,7 +4327,7 @@ class FdfParser:
                             FvList.append(elementRegionData.upper())\r
         return FvList\r
 \r
                             FvList.append(elementRegionData.upper())\r
         return FvList\r
 \r

-    ## __GetReferencedFdFvTuple() method\r
+    ## _GetReferencedFdFvTuple() method\r

     #\r
     #   Get FD and FV list referenced by a FFS file\r
     #\r
     #\r
     #   Get FD and FV list referenced by a FFS file\r
     #\r


@@ -4598,18 +4336,17 @@ class FdfParser:
     #   @param  RefFdList   referenced FD by section\r
     #   @param  RefFvList   referenced FV by section\r
     #\r
     #   @param  RefFdList   referenced FD by section\r
     #   @param  RefFvList   referenced FV by section\r
     #\r

-    def __GetReferencedFdFvTuple(self, FvObj, RefFdList = [], RefFvList = []):\r
-\r
+    def _GetReferencedFdFvTuple(self, FvObj, RefFdList = [], RefFvList = []):\r

         for FfsObj in FvObj.FfsList:\r
         for FfsObj in FvObj.FfsList:\r

-            if isinstance(FfsObj, FfsFileStatement.FileStatement):\r
+            if isinstance(FfsObj, FileStatement):\r

                 if FfsObj.FvName is not None and FfsObj.FvName.upper() not in RefFvList:\r
                     RefFvList.append(FfsObj.FvName.upper())\r
                 elif FfsObj.FdName is not None and FfsObj.FdName.upper() not in RefFdList:\r
                     RefFdList.append(FfsObj.FdName.upper())\r
                 else:\r
                 if FfsObj.FvName is not None and FfsObj.FvName.upper() not in RefFvList:\r
                     RefFvList.append(FfsObj.FvName.upper())\r
                 elif FfsObj.FdName is not None and FfsObj.FdName.upper() not in RefFdList:\r
                     RefFdList.append(FfsObj.FdName.upper())\r
                 else:\r

-                    self.__GetReferencedFdFvTupleFromSection(FfsObj, RefFdList, RefFvList)\r
+                    self._GetReferencedFdFvTupleFromSection(FfsObj, RefFdList, RefFvList)\r

 \r
 \r

-    ## __GetReferencedFdFvTupleFromSection() method\r
+    ## _GetReferencedFdFvTupleFromSection() method\r

     #\r
     #   Get FD and FV list referenced by a FFS section\r
     #\r
     #\r
     #   Get FD and FV list referenced by a FFS section\r
     #\r


@@ -4618,20 +4355,18 @@ class FdfParser:
     #   @param  FdList      referenced FD by section\r
     #   @param  FvList      referenced FV by section\r
     #\r
     #   @param  FdList      referenced FD by section\r
     #   @param  FvList      referenced FV by section\r
     #\r

-    def __GetReferencedFdFvTupleFromSection(self, FfsFile, FdList = [], FvList = []):\r
-\r
-        SectionStack = []\r
-        SectionStack.extend(FfsFile.SectionList)\r
+    def _GetReferencedFdFvTupleFromSection(self, FfsFile, FdList = [], FvList = []):\r
+        SectionStack = list(FfsFile.SectionList)\r

         while SectionStack != []:\r
             SectionObj = SectionStack.pop()\r
         while SectionStack != []:\r
             SectionObj = SectionStack.pop()\r

-            if isinstance(SectionObj, FvImageSection.FvImageSection):\r
+            if isinstance(SectionObj, FvImageSection):\r

                 if SectionObj.FvName is not None and SectionObj.FvName.upper() not in FvList:\r
                     FvList.append(SectionObj.FvName.upper())\r
                 if SectionObj.Fv is not None and SectionObj.Fv.UiFvName is not None and SectionObj.Fv.UiFvName.upper() not in FvList:\r
                     FvList.append(SectionObj.Fv.UiFvName.upper())\r
                 if SectionObj.FvName is not None and SectionObj.FvName.upper() not in FvList:\r
                     FvList.append(SectionObj.FvName.upper())\r
                 if SectionObj.Fv is not None and SectionObj.Fv.UiFvName is not None and SectionObj.Fv.UiFvName.upper() not in FvList:\r
                     FvList.append(SectionObj.Fv.UiFvName.upper())\r

-                    self.__GetReferencedFdFvTuple(SectionObj.Fv, FdList, FvList)\r
+                    self._GetReferencedFdFvTuple(SectionObj.Fv, FdList, FvList)\r

 \r
 \r

-            if isinstance(SectionObj, CompressSection.CompressSection) or isinstance(SectionObj, GuidSection.GuidSection):\r
+            if isinstance(SectionObj, CompressSection) or isinstance(SectionObj, GuidSection):\r

                 SectionStack.extend(SectionObj.SectionList)\r
 \r
     ## CycleReferenceCheck() method\r
                 SectionStack.extend(SectionObj.SectionList)\r
 \r
     ## CycleReferenceCheck() method\r


@@ -4647,46 +4382,45 @@ class FdfParser:
         # Check the cycle between FV and FD image\r
         #\r
         MaxLength = len (self.Profile.FvDict)\r
         # Check the cycle between FV and FD image\r
         #\r
         MaxLength = len (self.Profile.FvDict)\r

-        for FvName in self.Profile.FvDict.keys():\r
+        for FvName in self.Profile.FvDict:\r

             LogStr = "\nCycle Reference Checking for FV: %s\n" % FvName\r
             LogStr = "\nCycle Reference Checking for FV: %s\n" % FvName\r

-            RefFvStack = []\r
-            RefFvStack.append(FvName)\r
-            FdAnalyzedList = []\r
-            \r
+            RefFvStack = set(FvName)\r
+            FdAnalyzedList = set()\r
+\r

             Index = 0\r
             Index = 0\r

-            while RefFvStack != [] and Index < MaxLength:\r
+            while RefFvStack and Index < MaxLength:\r

                 Index = Index + 1\r
                 FvNameFromStack = RefFvStack.pop()\r
                 Index = Index + 1\r
                 FvNameFromStack = RefFvStack.pop()\r

-                if FvNameFromStack.upper() in self.Profile.FvDict.keys():\r
+                if FvNameFromStack.upper() in self.Profile.FvDict:\r

                     FvObj = self.Profile.FvDict[FvNameFromStack.upper()]\r
                 else:\r
                     continue\r
 \r
                 RefFdList = []\r
                 RefFvList = []\r
                     FvObj = self.Profile.FvDict[FvNameFromStack.upper()]\r
                 else:\r
                     continue\r
 \r
                 RefFdList = []\r
                 RefFvList = []\r

-                self.__GetReferencedFdFvTuple(FvObj, RefFdList, RefFvList)\r
+                self._GetReferencedFdFvTuple(FvObj, RefFdList, RefFvList)\r

 \r
                 for RefFdName in RefFdList:\r
                     if RefFdName in FdAnalyzedList:\r
                         continue\r
 \r
                     LogStr += "FV %s contains FD %s\n" % (FvNameFromStack, RefFdName)\r
 \r
                 for RefFdName in RefFdList:\r
                     if RefFdName in FdAnalyzedList:\r
                         continue\r
 \r
                     LogStr += "FV %s contains FD %s\n" % (FvNameFromStack, RefFdName)\r

-                    FvInFdList = self.__GetFvInFd(RefFdName)\r
+                    FvInFdList = self._GetFvInFd(RefFdName)\r

                     if FvInFdList != []:\r
                         for FvNameInFd in FvInFdList:\r
                     if FvInFdList != []:\r
                         for FvNameInFd in FvInFdList:\r

-                            LogStr += "FD %s contains FV %s\n" % (RefFdName,FvNameInFd)\r
+                            LogStr += "FD %s contains FV %s\n" % (RefFdName, FvNameInFd)\r

                             if FvNameInFd not in RefFvStack:\r
                             if FvNameInFd not in RefFvStack:\r

-                                RefFvStack.append(FvNameInFd)\r
+                                RefFvStack.add(FvNameInFd)\r

 \r
                             if FvName in RefFvStack or FvNameFromStack in RefFvStack:\r
                                 EdkLogger.info(LogStr)\r
                                 return True\r
 \r
                             if FvName in RefFvStack or FvNameFromStack in RefFvStack:\r
                                 EdkLogger.info(LogStr)\r
                                 return True\r

-                    FdAnalyzedList.append(RefFdName)\r
+                    FdAnalyzedList.add(RefFdName)\r

 \r
                 for RefFvName in RefFvList:\r
                     LogStr += "FV %s contains FV %s\n" % (FvNameFromStack, RefFvName)\r
                     if RefFvName not in RefFvStack:\r
 \r
                 for RefFvName in RefFvList:\r
                     LogStr += "FV %s contains FV %s\n" % (FvNameFromStack, RefFvName)\r
                     if RefFvName not in RefFvStack:\r

-                        RefFvStack.append(RefFvName)\r
+                        RefFvStack.add(RefFvName)\r

 \r
                     if FvName in RefFvStack or FvNameFromStack in RefFvStack:\r
                         EdkLogger.info(LogStr)\r
 \r
                     if FvName in RefFvStack or FvNameFromStack in RefFvStack:\r
                         EdkLogger.info(LogStr)\r


@@ -4696,28 +4430,27 @@ class FdfParser:
         # Check the cycle between Capsule and FD image\r
         #\r
         MaxLength = len (self.Profile.CapsuleDict)\r
         # Check the cycle between Capsule and FD image\r
         #\r
         MaxLength = len (self.Profile.CapsuleDict)\r

-        for CapName in self.Profile.CapsuleDict.keys():\r
+        for CapName in self.Profile.CapsuleDict:\r

             #\r
             # Capsule image to be checked.\r
             #\r
             LogStr = "\n\n\nCycle Reference Checking for Capsule: %s\n" % CapName\r
             #\r
             # Capsule image to be checked.\r
             #\r
             LogStr = "\n\n\nCycle Reference Checking for Capsule: %s\n" % CapName\r

-            RefCapStack = []\r
-            RefCapStack.append(CapName)\r
-            FdAnalyzedList = []\r
-            FvAnalyzedList = []\r
-            \r
+            RefCapStack = {CapName}\r
+            FdAnalyzedList = set()\r
+            FvAnalyzedList = set()\r
+\r

             Index = 0\r
             Index = 0\r

-            while RefCapStack != [] and Index < MaxLength:\r
+            while RefCapStack and Index < MaxLength:\r

                 Index = Index + 1\r
                 CapNameFromStack = RefCapStack.pop()\r
                 Index = Index + 1\r
                 CapNameFromStack = RefCapStack.pop()\r

-                if CapNameFromStack.upper() in self.Profile.CapsuleDict.keys():\r
+                if CapNameFromStack.upper() in self.Profile.CapsuleDict:\r

                     CapObj = self.Profile.CapsuleDict[CapNameFromStack.upper()]\r
                 else:\r
                     continue\r
 \r
                 RefFvList = []\r
                 RefFdList = []\r
                     CapObj = self.Profile.CapsuleDict[CapNameFromStack.upper()]\r
                 else:\r
                     continue\r
 \r
                 RefFvList = []\r
                 RefFdList = []\r

-                self.__GetReferencedFdCapTuple(CapObj, RefFdList, RefFvList)\r
+                self._GetReferencedFdCapTuple(CapObj, RefFdList, RefFvList)\r

 \r
                 FvListLength = 0\r
                 FdListLength = 0\r
 \r
                 FvListLength = 0\r
                 FdListLength = 0\r


@@ -4727,25 +4460,21 @@ class FdfParser:
                             continue\r
 \r
                         LogStr += "Capsule %s contains FD %s\n" % (CapNameFromStack, RefFdName)\r
                             continue\r
 \r
                         LogStr += "Capsule %s contains FD %s\n" % (CapNameFromStack, RefFdName)\r

-                        CapInFdList = self.__GetCapInFd(RefFdName)\r
-                        if CapInFdList != []:\r
-                            for CapNameInFd in CapInFdList:\r
-                                LogStr += "FD %s contains Capsule %s\n" % (RefFdName,CapNameInFd)\r
-                                if CapNameInFd not in RefCapStack:\r
-                                    RefCapStack.append(CapNameInFd)\r
-\r
-                                if CapName in RefCapStack or CapNameFromStack in RefCapStack:\r
-                                    EdkLogger.info(LogStr)\r
-                                    return True\r
-\r
-                        FvInFdList = self.__GetFvInFd(RefFdName)\r
-                        if FvInFdList != []:\r
-                            for FvNameInFd in FvInFdList:\r
-                                LogStr += "FD %s contains FV %s\n" % (RefFdName,FvNameInFd)\r
-                                if FvNameInFd not in RefFvList:\r
-                                    RefFvList.append(FvNameInFd)\r
-\r
-                        FdAnalyzedList.append(RefFdName)\r
+                        for CapNameInFd in self._GetCapInFd(RefFdName):\r
+                            LogStr += "FD %s contains Capsule %s\n" % (RefFdName, CapNameInFd)\r
+                            if CapNameInFd not in RefCapStack:\r
+                                RefCapStack.append(CapNameInFd)\r
+\r
+                            if CapName in RefCapStack or CapNameFromStack in RefCapStack:\r
+                                EdkLogger.info(LogStr)\r
+                                return True\r
+\r
+                        for FvNameInFd in self._GetFvInFd(RefFdName):\r
+                            LogStr += "FD %s contains FV %s\n" % (RefFdName, FvNameInFd)\r
+                            if FvNameInFd not in RefFvList:\r
+                                RefFvList.append(FvNameInFd)\r
+\r
+                        FdAnalyzedList.add(RefFdName)\r

                     #\r
                     # the number of the parsed FV and FD image\r
                     #\r
                     #\r
                     # the number of the parsed FV and FD image\r
                     #\r


@@ -4755,12 +4484,12 @@ class FdfParser:
                         if RefFvName in FvAnalyzedList:\r
                             continue\r
                         LogStr += "Capsule %s contains FV %s\n" % (CapNameFromStack, RefFvName)\r
                         if RefFvName in FvAnalyzedList:\r
                             continue\r
                         LogStr += "Capsule %s contains FV %s\n" % (CapNameFromStack, RefFvName)\r

-                        if RefFvName.upper() in self.Profile.FvDict.keys():\r
+                        if RefFvName.upper() in self.Profile.FvDict:\r

                             FvObj = self.Profile.FvDict[RefFvName.upper()]\r
                         else:\r
                             continue\r
                             FvObj = self.Profile.FvDict[RefFvName.upper()]\r
                         else:\r
                             continue\r

-                        self.__GetReferencedFdFvTuple(FvObj, RefFdList, RefFvList)\r
-                        FvAnalyzedList.append(RefFvName)\r
+                        self._GetReferencedFdFvTuple(FvObj, RefFdList, RefFvList)\r
+                        FvAnalyzedList.add(RefFvName)\r

 \r
         return False\r
 \r
 \r
         return False\r
 \r


@@ -4772,16 +4501,16 @@ if __name__ == "__main__":
     import sys\r
     try:\r
         test_file = sys.argv[1]\r
     import sys\r
     try:\r
         test_file = sys.argv[1]\r

-    except IndexError, v:\r
-        print "Usage: %s filename" % sys.argv[0]\r
+    except IndexError as v:\r
+        print("Usage: %s filename" % sys.argv[0])\r

         sys.exit(1)\r
 \r
     parser = FdfParser(test_file)\r
     try:\r
         parser.ParseFile()\r
         parser.CycleReferenceCheck()\r
         sys.exit(1)\r
 \r
     parser = FdfParser(test_file)\r
     try:\r
         parser.ParseFile()\r
         parser.CycleReferenceCheck()\r

-    except Warning, X:\r
-        print str(X)\r
+    except Warning as X:\r
+        print(str(X))\r

     else:\r
     else:\r

-        print "Success!"\r
+        print("Success!")\r

 \r
 \r