BaseTools: change hex parsing to use built in

[mirror_edk2.git] / BaseTools / Source / Python / Common / FdfParserLite.py

## @file\r
# parse FDF file\r
#\r
#  Copyright (c) 2007 - 2018, Intel Corporation. All rights reserved.<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
#\r
\r
##\r
# Import Modules\r
#\r
import re\r
import Common.LongFilePathOs as os\r
\r
import CommonDataClass.FdfClass\r
from Common.LongFilePathSupport import OpenLongFilePath as open\r
from Common.MultipleWorkspace import MultipleWorkspace as mws\r
from Common.RangeExpression import RangeExpression\r
from Common.GlobalData import *\r
import string\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
IncludeFileList = []\r
# Macro passed from command line, which has greatest priority and can NOT be overridden by those in FDF\r
InputMacroDict = {}\r
# All Macro values when parsing file, not replace existing Macro\r
AllMacroList = []\r
\r
FileExtensionPattern = re.compile(r'([a-zA-Z][a-zA-Z0-9]*)')\r
TokenFindPattern = re.compile(r'([a-zA-Z0-9\-]+|\$\(TARGET\)|\*)_([a-zA-Z0-9\-]+|\$\(TOOL_CHAIN_TAG\)|\*)_([a-zA-Z0-9\-]+|\$\(ARCH\)|\*)')\r
\r
def GetRealFileLine (File, Line):\r
    \r
    InsertedLines = 0\r
    for Profile in IncludeFileList:\r
        if Line >= Profile.InsertStartLineNumber and Line < Profile.InsertStartLineNumber + Profile.InsertAdjust + len(Profile.FileLinesList):\r
            return (Profile.FileName, Line - Profile.InsertStartLineNumber + 1)\r
        if Line >= Profile.InsertStartLineNumber + Profile.InsertAdjust + len(Profile.FileLinesList):\r
            InsertedLines += Profile.InsertAdjust + len(Profile.FileLinesList)\r
    \r
    return (File, Line - InsertedLines)\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
#\r
class Warning (Exception):\r
    ## The constructor\r
    #\r
    #   @param  self        The object pointer\r
    #   @param  Str         The message to record\r
    #   @param  File        The FDF name\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
        self.message = Str + str(self.LineNumber)\r
        self.ToolName = 'FDF Parser'\r
        \r
## The MACRO class that used to record macro value data when parsing include file\r
#\r
#\r
class MacroProfile :\r
    ## The constructor\r
    #\r
    #   @param  self        The object pointer\r
    #   @param  FileName    The file that to be parsed\r
    #\r
    def __init__(self, FileName, Line):\r
        self.FileName = FileName        \r
        self.DefinedAtLine  = Line\r
        self.MacroName = None\r
        self.MacroValue = None\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
    ## The constructor\r
    #\r
    #   @param  self        The object pointer\r
    #   @param  FileName    The file that to be parsed\r
    #\r
    def __init__(self, FileName):\r
        self.FileName = FileName\r
        self.FileLinesList = []\r
        try:\r
            fsock = open(FileName, "rb", 0)\r
            try:\r
                self.FileLinesList = fsock.readlines()\r
            finally:\r
                fsock.close()\r
\r
        except IOError:\r
            raise Warning("Error when opening file %s" % FileName)\r
        \r
        self.InsertStartLineNumber = None\r
        self.InsertAdjust = 0\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
    ## The constructor\r
    #\r
    #   @param  self        The object pointer\r
    #   @param  FileName    The file that to be parsed\r
    #\r
    def __init__(self, FileName):\r
        self.FileLinesList = []\r
        try:\r
            fsock = open(FileName, "rb", 0)\r
            try:\r
                self.FileLinesList = fsock.readlines()\r
            finally:\r
                fsock.close()\r
\r
        except IOError:\r
            raise Warning("Error when opening file %s" % FileName)\r
        \r
        self.PcdDict = {}\r
        self.InfList = []\r
        \r
        self.PcdFileLineDict = {}\r
        self.InfFileLineList = []\r
        \r
        self.FdDict = {}\r
        self.FvDict = {}\r
        self.CapsuleList = []\r
#        self.VtfList = []\r
#        self.RuleDict = {}\r
\r
## The syntax parser for FDF\r
#\r
# PreprocessFile method should be called prior to ParseFile\r
# CycleReferenceCheck method can detect cycles in FDF contents\r
#\r
# GetNext*** procedures mean these procedures will get next token first, then make judgement.\r
# Get*** procedures mean these procedures will make judgement on current token only.\r
#        \r
class FdfParser(object):\r
    ## The constructor\r
    #\r
    #   @param  self        The object pointer\r
    #   @param  FileName    The file that to be parsed\r
    #\r
    def __init__(self, FileName):\r
        self.Profile = FileProfile(FileName)\r
        self.FileName = FileName\r
        self.CurrentLineNumber = 1\r
        self.CurrentOffsetWithinLine = 0\r
        self.CurrentFdName = None\r
        self.CurrentFvName = None\r
        self.__Token = ""\r
        self.__SkippedChars = ""\r
        \r
        self.__WipeOffArea = []\r
\r
    ## __IsWhiteSpace() method\r
    #\r
    #   Whether char at current FileBufferPos is whitespace\r
    #\r
    #   @param  self        The object pointer\r
    #   @param  Char        The char to test\r
    #   @retval True        The char is a kind of white space\r
    #   @retval False       The char is NOT a kind of white space\r
    #\r
    def __IsWhiteSpace(self, Char):\r
        if Char in (T_CHAR_NULL, T_CHAR_CR, T_CHAR_SPACE, T_CHAR_TAB, T_CHAR_LF):\r
            return True\r
        else:\r
            return False\r
\r
    ## __SkipWhiteSpace() method\r
    #\r
    #   Skip white spaces from current char, return number of chars skipped\r
    #\r
    #   @param  self        The object pointer\r
    #   @retval Count       The number of chars skipped\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
            else:\r
                Count = Count - 1\r
                return Count\r
\r
    ## __EndOfFile() method\r
    #\r
    #   Judge current buffer pos is at file end\r
    #\r
    #   @param  self        The object pointer\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
        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
            return True\r
        else:\r
            return False\r
\r
    ## __EndOfLine() method\r
    #\r
    #   Judge current buffer pos is at line end\r
    #\r
    #   @param  self        The object pointer\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
        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
    \r
    ## Rewind() method\r
    #\r
    #   Reset file data buffer to the initial state\r
    #\r
    #   @param  self        The object pointer\r
    #\r
    def Rewind(self):\r
        self.CurrentLineNumber = 1\r
        self.CurrentOffsetWithinLine = 0\r
    \r
    ## __UndoOneChar() method\r
    #\r
    #   Go back one char in the file buffer\r
    #\r
    #   @param  self        The object pointer\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
        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
        else:\r
            self.CurrentOffsetWithinLine -= 1\r
        return True\r
        \r
    ## __GetOneChar() method\r
    #\r
    #   Move forward one char in the file buffer\r
    #\r
    #   @param  self        The object pointer\r
    #  \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
    ## __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
    def __CurrentChar(self):\r
        return self.Profile.FileLinesList[self.CurrentLineNumber - 1][self.CurrentOffsetWithinLine]\r
    \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
    def __NextChar(self):\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
        \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
    def __SetCurrentCharValue(self, Value):\r
        self.Profile.FileLinesList[self.CurrentLineNumber - 1][self.CurrentOffsetWithinLine] = Value\r
        \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
    def __CurrentLine(self):\r
        return self.Profile.FileLinesList[self.CurrentLineNumber - 1]\r
        \r
    def __StringToList(self):\r
        self.Profile.FileLinesList = [list(s) for s in self.Profile.FileLinesList]\r
        self.Profile.FileLinesList[-1].append(' ')\r
\r
    def __ReplaceMacros(self, Str, File, Line):\r
        MacroEnd = 0\r
        while Str.find('$(', MacroEnd) >= 0:\r
            MacroStart = Str.find('$(', MacroEnd)\r
            if Str.find(')', MacroStart) > 0:\r
                MacroEnd = Str.find(')', MacroStart)\r
                Name = Str[MacroStart + 2 : MacroEnd]\r
                Value = None\r
                if Name in InputMacroDict:\r
                    Value = InputMacroDict[Name]\r
                   \r
                else:\r
                    for Profile in AllMacroList:\r
                        if Profile.FileName == File and Profile.MacroName == Name and Profile.DefinedAtLine <= Line:\r
                            Value = Profile.MacroValue\r
                            \r
                if Value is not None:\r
                    Str = Str.replace('$(' + Name + ')', Value)\r
                    MacroEnd = MacroStart + len(Value) \r
                \r
            else:\r
                raise Warning("Macro not complete At Line ", self.FileName, self.CurrentLineNumber)\r
        return Str\r
\r
    def __ReplaceFragment(self, StartPos, EndPos, Value=' '):\r
        if StartPos[0] == EndPos[0]:\r
            Offset = StartPos[1]\r
            while Offset <= EndPos[1]:\r
                self.Profile.FileLinesList[StartPos[0]][Offset] = Value\r
                Offset += 1\r
            return\r
        \r
        Offset = StartPos[1]\r
        while self.Profile.FileLinesList[StartPos[0]][Offset] not in ('\r', '\n'):\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
                self.Profile.FileLinesList[Line][Offset] = Value\r
                Offset += 1\r
            Line += 1\r
            \r
        Offset = 0\r
        while Offset <= EndPos[1]:\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
    ## PreprocessFile() method\r
    #\r
    #   Preprocess file contents, replace comments with spaces.\r
    #   In the end, rewind the file buffer pointer to the beginning\r
    #   BUGBUG: No !include statement processing contained in this procedure\r
    #   !include statement should be expanded at the same FileLinesList[CurrentLineNumber - 1]\r
    #\r
    #   @param  self        The object pointer\r
    #   \r
    def PreprocessFile(self):\r
        \r
        self.Rewind()\r
        InComment = False\r
        DoubleSlashComment = False\r
        HashComment = False\r
        # HashComment in quoted string " " is ignored.\r
        InString = False    \r
        \r
        while not self.__EndOfFile():\r
            \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
            if self.__CurrentChar() == T_CHAR_LF:\r
                self.CurrentLineNumber += 1\r
                self.CurrentOffsetWithinLine = 0\r
                if InComment and DoubleSlashComment:\r
                    InComment = False\r
                    DoubleSlashComment = False\r
                if InComment and HashComment:\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
                InComment = False\r
            # set comments to spaces\r
            elif InComment:\r
                self.__SetCurrentCharValue(T_CHAR_SPACE)\r
                self.__GetOneChar()\r
            # check for // comment\r
            elif self.__CurrentChar() == T_CHAR_SLASH and self.__NextChar() == T_CHAR_SLASH and not self.__EndOfLine():\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
                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
                InComment = True\r
            else:\r
                self.__GetOneChar()\r
        \r
        # restore from ListOfList to ListOfString\r
        self.Profile.FileLinesList = ["".join(list) for list in self.Profile.FileLinesList]\r
        self.Rewind()\r
\r
    ## PreprocessIncludeFile() method\r
    #\r
    #   Preprocess file contents, replace !include statements with file contents.\r
    #   In the end, rewind the file buffer pointer to the beginning\r
    #\r
    #   @param  self        The object pointer\r
    #   \r
    def PreprocessIncludeFile(self):\r
        \r
        while self.__GetNextToken():\r
            \r
            if self.__Token == '!include':\r
                IncludeLine = self.CurrentLineNumber\r
                IncludeOffset = self.CurrentOffsetWithinLine - len('!include')\r
                if not self.__GetNextToken():\r
                    raise Warning("expected include file name At Line ", self.FileName, self.CurrentLineNumber)\r
                IncFileName = self.__Token\r
                if not os.path.isabs(IncFileName):\r
                    if IncFileName.startswith('$(WORKSPACE)'):\r
                        Str = mws.handleWsMacro(IncFileName)\r
                        Str = Str.replace('$(WORKSPACE)', os.environ.get('WORKSPACE'))\r
                        if os.path.exists(Str):\r
                            if not os.path.isabs(Str):\r
                                Str = os.path.abspath(Str)\r
                        IncFileName = Str\r
                    else:\r
                        # file is in the same dir with FDF file\r
                        FullFdf = self.FileName\r
                        if not os.path.isabs(self.FileName):\r
                            FullFdf = mws.join(os.environ.get('WORKSPACE'), self.FileName)\r
                \r
                        IncFileName = os.path.join(os.path.dirname(FullFdf), IncFileName)\r
                    \r
                if not os.path.exists(os.path.normpath(IncFileName)):\r
                    raise Warning("Include file not exists At Line ", self.FileName, self.CurrentLineNumber)\r
                \r
                IncFileProfile = IncludeFileProfile(os.path.normpath(IncFileName))\r
                \r
                CurrentLine = self.CurrentLineNumber\r
                CurrentOffset = self.CurrentOffsetWithinLine\r
                # list index of the insertion, note that line number is 'CurrentLine + 1'\r
                InsertAtLine = CurrentLine\r
                IncFileProfile.InsertStartLineNumber = InsertAtLine + 1\r
                # deal with remaining portions after "!include filename", if exists.\r
                if self.__GetNextToken():\r
                    if self.CurrentLineNumber == CurrentLine:\r
                        RemainingLine = self.__CurrentLine()[CurrentOffset:]\r
                        self.Profile.FileLinesList.insert(self.CurrentLineNumber, RemainingLine)\r
                        IncFileProfile.InsertAdjust += 1\r
                        self.CurrentLineNumber += 1\r
                        self.CurrentOffsetWithinLine = 0\r
                \r
                for Line in IncFileProfile.FileLinesList:\r
                    self.Profile.FileLinesList.insert(InsertAtLine, Line)\r
                    self.CurrentLineNumber += 1\r
                    InsertAtLine += 1    \r
                \r
                IncludeFileList.append(IncFileProfile)\r
                \r
                # comment out the processed include file statement\r
                TempList = list(self.Profile.FileLinesList[IncludeLine - 1])\r
                TempList.insert(IncludeOffset, '#')\r
                self.Profile.FileLinesList[IncludeLine - 1] = ''.join(TempList)\r
                \r
        self.Rewind()\r
\r
    ## PreprocessIncludeFile() method\r
    #\r
    #   Preprocess file contents, replace !include statements with file contents.\r
    #   In the end, rewind the file buffer pointer to the beginning\r
    #\r
    #   @param  self        The object pointer\r
    #   \r
    def PreprocessConditionalStatement(self):\r
        # IfList is a stack of if branches with elements of list [Pos, CondSatisfied, BranchDetermined]\r
        IfList = []\r
        while self.__GetNextToken():\r
            if self.__Token == 'DEFINE':\r
                DefineLine = self.CurrentLineNumber - 1\r
                DefineOffset = self.CurrentOffsetWithinLine - len('DEFINE')\r
                if not self.__GetNextToken():\r
                    raise Warning("expected Macro name At Line ", self.FileName, self.CurrentLineNumber)\r
                Macro = self.__Token\r
                if not self.__IsToken( "="):\r
                    raise Warning("expected '=' At Line ", self.FileName, self.CurrentLineNumber)\r
                \r
                if not self.__GetNextToken():\r
                    raise Warning("expected value At Line ", self.FileName, self.CurrentLineNumber)\r
                \r
                if self.__GetStringData():\r
                    pass\r
                Value = self.__Token\r
                if not Macro in InputMacroDict:\r
                    FileLineTuple = GetRealFileLine(self.FileName, DefineLine + 1)\r
                    MacProfile = MacroProfile(FileLineTuple[0], FileLineTuple[1])\r
                    MacProfile.MacroName = Macro\r
                    MacProfile.MacroValue = Value\r
                    AllMacroList.append(MacProfile)\r
                self.__WipeOffArea.append(((DefineLine, DefineOffset), (self.CurrentLineNumber - 1, self.CurrentOffsetWithinLine - 1)))\r
            \r
            elif self.__Token in ('!ifdef', '!ifndef', '!if'):\r
                IfStartPos = (self.CurrentLineNumber - 1, self.CurrentOffsetWithinLine - len(self.__Token))\r
                IfList.append([IfStartPos, None, None])\r
                CondLabel = self.__Token\r
                \r
                MacroName, NotFlag = self.__GetMacroName() \r
                NotDefineFlag = False\r
                if CondLabel == '!ifndef':\r
                    NotDefineFlag = True\r
                if CondLabel == '!ifdef' or CondLabel == '!ifndef':\r
                    if NotFlag:\r
                        raise Warning("'NOT' operation not allowed for Macro name At Line ", self.FileName, self.CurrentLineNumber)\r
                    \r
                if CondLabel == '!if':\r
                        \r
                    if not self.__GetNextOp():\r
                        raise Warning("expected !endif At Line ", self.FileName, self.CurrentLineNumber)\r
                    \r
                    if self.__Token in ('!=', '==', '>', '<', '>=', '<='):\r
                        Op = self.__Token\r
                        if not self.__GetNextToken():\r
                            raise Warning("expected value At Line ", self.FileName, self.CurrentLineNumber)\r
                        if self.__GetStringData():\r
                            pass\r
                        MacroValue = self.__Token\r
                        ConditionSatisfied = self.__EvaluateConditional(MacroName, IfList[-1][0][0] + 1, Op, MacroValue)\r
                        if NotFlag:\r
                            ConditionSatisfied = not ConditionSatisfied\r
                        BranchDetermined = ConditionSatisfied\r
                    else:\r
                        self.CurrentOffsetWithinLine -= len(self.__Token)                        \r
                        ConditionSatisfied = self.__EvaluateConditional(MacroName, IfList[-1][0][0] + 1, None, 'Bool')\r
                        if NotFlag:\r
                            ConditionSatisfied = not ConditionSatisfied\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
                        \r
                else:\r
                    ConditionSatisfied = self.__EvaluateConditional(MacroName, IfList[-1][0][0] + 1)\r
                    if NotDefineFlag:\r
                        ConditionSatisfied = not ConditionSatisfied\r
                    BranchDetermined = ConditionSatisfied\r
                    IfList[-1] = [IfList[-1][0], ConditionSatisfied, BranchDetermined]\r
                    if ConditionSatisfied:\r
                        self.__WipeOffArea.append((IfStartPos, (self.CurrentLineNumber - 1, self.CurrentOffsetWithinLine - 1)))\r
                    \r
            elif self.__Token in ('!elseif', '!else'):\r
                ElseStartPos = (self.CurrentLineNumber - 1, self.CurrentOffsetWithinLine - len(self.__Token))\r
                if len(IfList) <= 0:\r
                    raise Warning("Missing !if statement At Line ", self.FileName, self.CurrentLineNumber)\r
                if IfList[-1][1]:\r
                    IfList[-1] = [ElseStartPos, False, True]\r
                    self.__WipeOffArea.append((ElseStartPos, (self.CurrentLineNumber - 1, self.CurrentOffsetWithinLine - 1)))\r
                else:\r
                    self.__WipeOffArea.append((IfList[-1][0], ElseStartPos))\r
                    IfList[-1] = [ElseStartPos, True, IfList[-1][2]]\r
                    if self.__Token == '!elseif':\r
                        MacroName, NotFlag = self.__GetMacroName() \r
                        if not self.__GetNextOp():\r
                            raise Warning("expected !endif At Line ", self.FileName, self.CurrentLineNumber)\r
                    \r
                        if self.__Token in ('!=', '==', '>', '<', '>=', '<='):\r
                            Op = self.__Token\r
                            if not self.__GetNextToken():\r
                                raise Warning("expected value At Line ", self.FileName, self.CurrentLineNumber)\r
                            if self.__GetStringData():\r
                                pass\r
                            MacroValue = self.__Token\r
                            ConditionSatisfied = self.__EvaluateConditional(MacroName, IfList[-1][0][0] + 1, Op, MacroValue)\r
                            if NotFlag:\r
                                ConditionSatisfied = not ConditionSatisfied\r
\r
                        else:\r
                            self.CurrentOffsetWithinLine -= len(self.__Token)                        \r
                            ConditionSatisfied = self.__EvaluateConditional(MacroName, IfList[-1][0][0] + 1, None, 'Bool')\r
                            if NotFlag:\r
                                ConditionSatisfied = not ConditionSatisfied\r
\r
                        IfList[-1] = [IfList[-1][0], ConditionSatisfied, IfList[-1][2]]\r
                    \r
                    if IfList[-1][1]:\r
                        if IfList[-1][2]:\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
\r
                \r
            elif self.__Token == '!endif':\r
                if IfList[-1][1]:\r
                    self.__WipeOffArea.append(((self.CurrentLineNumber - 1, self.CurrentOffsetWithinLine - len('!endif')), (self.CurrentLineNumber - 1, self.CurrentOffsetWithinLine - 1)))\r
                else:\r
                    self.__WipeOffArea.append((IfList[-1][0], (self.CurrentLineNumber - 1, self.CurrentOffsetWithinLine - 1)))\r
                \r
                IfList.pop()\r
                \r
                    \r
        if len(IfList) > 0:\r
            raise Warning("Missing !endif At Line ", self.FileName, self.CurrentLineNumber)\r
        self.Rewind()\r
\r
    def __EvaluateConditional(self, Name, Line, Op = None, Value = None):\r
        \r
        FileLineTuple = GetRealFileLine(self.FileName, Line)\r
        if Name in InputMacroDict:\r
            MacroValue = InputMacroDict[Name]\r
            if Op is None:\r
                if Value == 'Bool' and MacroValue is None or MacroValue.upper() == 'FALSE':\r
                    return False\r
                return True\r
            elif Op == '!=':\r
                if Value != MacroValue:\r
                    return True\r
                else:\r
                    return False\r
            elif Op == '==':\r
                if Value == MacroValue:\r
                    return True\r
                else:\r
                    return False\r
            else:\r
                if (self.__IsHex(Value) or Value.isdigit()) and (self.__IsHex(MacroValue) or (MacroValue is not None and MacroValue.isdigit())):\r
                    InputVal = long(Value, 0)\r
                    MacroVal = long(MacroValue, 0)\r
                    if Op == '>':\r
                        if MacroVal > InputVal:\r
                            return True\r
                        else:\r
                            return False\r
                    elif Op == '>=':\r
                        if MacroVal >= InputVal:\r
                            return True\r
                        else:\r
                            return False\r
                    elif Op == '<':\r
                        if MacroVal < InputVal:\r
                            return True\r
                        else:\r
                            return False\r
                    elif Op == '<=':\r
                        if MacroVal <= InputVal:\r
                            return True\r
                        else:\r
                            return False\r
                    else:\r
                        return False\r
                else:\r
                    raise Warning("Value %s is not a number At Line ", self.FileName, Line)\r
                \r
        for Profile in AllMacroList:\r
            if Profile.FileName == FileLineTuple[0] and Profile.MacroName == Name and Profile.DefinedAtLine <= FileLineTuple[1]:\r
                if Op is None:\r
                    if Value == 'Bool' and Profile.MacroValue is None or Profile.MacroValue.upper() == 'FALSE':\r
                        return False\r
                    return True\r
                elif Op == '!=':\r
                    if Value != Profile.MacroValue:\r
                        return True\r
                    else:\r
                        return False\r
                elif Op == '==':\r
                    if Value == Profile.MacroValue:\r
                        return True\r
                    else:\r
                        return False\r
                else:\r
                    if (self.__IsHex(Value) or Value.isdigit()) and (self.__IsHex(Profile.MacroValue) or (Profile.MacroValue is not None and Profile.MacroValue.isdigit())):\r
                        InputVal = long(Value, 0)\r
                        MacroVal = long(Profile.MacroValue, 0)\r
                        if Op == '>':\r
                            if MacroVal > InputVal:\r
                                return True\r
                            else:\r
                                return False\r
                        elif Op == '>=':\r
                            if MacroVal >= InputVal:\r
                                return True\r
                            else:\r
                                return False\r
                        elif Op == '<':\r
                            if MacroVal < InputVal:\r
                                return True\r
                            else:\r
                                return False\r
                        elif Op == '<=':\r
                            if MacroVal <= InputVal:\r
                                return True\r
                            else:\r
                                return False\r
                        else:\r
                            return False\r
                    else:\r
                        raise Warning("Value %s is not a number At Line ", self.FileName, Line)\r
        \r
        return False\r
\r
    ## __IsToken() method\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
    #\r
    #   @param  self        The object pointer\r
    #   @param  String      The string to search\r
    #   @param  IgnoreCase  Indicate case sensitive/non-sensitive search, default is case sensitive\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
\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
        else:\r
            index = self.__CurrentLine()[self.CurrentOffsetWithinLine : ].find(String)\r
        if index == 0:\r
            self.CurrentOffsetWithinLine += len(String)\r
            self.__Token = self.__CurrentLine()[StartPos : self.CurrentOffsetWithinLine]\r
            return True\r
        return False\r
\r
    ## __IsKeyword() method\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
    #\r
    #   @param  self        The object pointer\r
    #   @param  Keyword     The string to search\r
    #   @param  IgnoreCase  Indicate case sensitive/non-sensitive search, default is case sensitive\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
\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
        else:\r
            index = self.__CurrentLine()[self.CurrentOffsetWithinLine : ].find(KeyWord)\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
                return False\r
            self.CurrentOffsetWithinLine += len(KeyWord)\r
            self.__Token = self.__CurrentLine()[StartPos : self.CurrentOffsetWithinLine]\r
            return True\r
        return False\r
\r
    ## __GetNextWord() method\r
    #\r
    #   Get next C name from file lines\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
    def __GetNextWord(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 == '_':\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
                    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
    ## __GetNextToken() method\r
    #\r
    #   Get next token unit before a seperator\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
    def __GetNextToken(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
        StartLine = self.CurrentLineNumber\r
        while not self.__EndOfLine():\r
            TempChar = self.__CurrentChar()\r
            # Try to find the end char that is not a space and not in seperator tuple.\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
                break\r
            else:\r
                break\r
#        else:\r
#            return False\r
\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
        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
    #\r
    #   Get next token unit before a seperator\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
    def __GetNextGuid(self):\r
        \r
        if not self.__GetNextToken():\r
            return False\r
        if gGuidPattern.match(self.__Token) is not None:\r
            return True\r
        else:\r
            self.__UndoToken()\r
            return False\r
\r
    ## __UndoToken() method\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
                return\r
        \r
        \r
        StartPos = self.CurrentOffsetWithinLine\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
            # 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
                    break\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
                return\r
            else:\r
                break\r
            \r
        self.__GetOneChar()\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
    #\r
    #   Get next HEX data before a seperator\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
    def __GetNextHexNumber(self):\r
        if not self.__GetNextToken():\r
            return False\r
        if self.__IsHex(self.__Token):\r
            return True\r
        else:\r
            self.__UndoToken()\r
            return False\r
        \r
    ## __GetNextDecimalNumber() method\r
    #\r
    #   Get next decimal data before a seperator\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
    def __GetNextDecimalNumber(self):\r
        if not self.__GetNextToken():\r
            return False\r
        if self.__Token.isdigit():\r
            return True\r
        else:\r
            self.__UndoToken()\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 PcdTokenSpaceCName.PcdCName At Line ", self.FileName, self.CurrentLineNumber)\r
        pcdTokenSpaceCName = self.__Token\r
        \r
        if not self.__IsToken( "."):\r
            raise Warning("expected PcdTokenSpaceCName.PcdCName At Line ", self.FileName, self.CurrentLineNumber)\r
        \r
        if not self.__GetNextWord():\r
            raise Warning("expected PcdTokenSpaceCName.PcdCName At Line ", self.FileName, self.CurrentLineNumber)\r
        pcdCName = self.__Token\r
        \r
        return (pcdCName, pcdTokenSpaceCName) \r
            \r
    ## __GetStringData() method\r
    #\r
    #   Get string contents quoted in ""\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
    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 At Line ", self.FileName, self.CurrentLineNumber)\r
            if currentLineNumber != self.CurrentLineNumber:\r
                raise Warning("Missing Quote \" for String At Line ", 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 At Line ", self.FileName, self.CurrentLineNumber)\r
            if currentLineNumber != self.CurrentLineNumber:\r
                raise Warning("Missing Quote \' for String At Line ", self.FileName, self.CurrentLineNumber)\r
            self.__Token = self.__SkippedChars.rstrip('\'')\r
            return True\r
        \r
        else:\r
            return False\r
            \r
    ## __SkipToToken() method\r
    #\r
    #   Search forward in file buffer for the string\r
    #   The skipped chars are put into self.__SkippedChars\r
    #\r
    #   @param  self        The object pointer\r
    #   @param  String      The string to search\r
    #   @param  IgnoreCase  Indicate case sensitive/non-sensitive search, default is case sensitive\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
        StartPos = self.GetFileBufferPos()\r
        \r
        self.__SkippedChars = ""\r
        while not self.__EndOfFile():\r
            index = -1\r
            if IgnoreCase:\r
                index = self.__CurrentLine()[self.CurrentOffsetWithinLine : ].upper().find(String.upper()) \r
            else:\r
                index = self.__CurrentLine()[self.CurrentOffsetWithinLine : ].find(String)\r
            if index == 0:\r
                self.CurrentOffsetWithinLine += len(String)\r
                self.__SkippedChars += String\r
                return True\r
            self.__SkippedChars += str(self.__CurrentChar())\r
            self.__GetOneChar()\r
            \r
        self.SetFileBufferPos( StartPos)\r
        self.__SkippedChars = ""\r
        return False\r
\r
    ## GetFileBufferPos() method\r
    #\r
    #   Return the tuple of current line and offset within the line\r
    #\r
    #   @param  self        The object pointer\r
    #   @retval Tuple       Line number and offset pair \r
    #\r
    def GetFileBufferPos(self):\r
        return (self.CurrentLineNumber, self.CurrentOffsetWithinLine)\r
    \r
    ## SetFileBufferPos() method\r
    #\r
    #   Restore the file buffer position\r
    #\r
    #   @param  self        The object pointer\r
    #   @param  Pos         The new file buffer position\r
    #\r
    def SetFileBufferPos(self, Pos):\r
        (self.CurrentLineNumber, self.CurrentOffsetWithinLine) = Pos\r
            \r
    ## ParseFile() method\r
    #\r
    #   Parse the file profile buffer to extract fd, fv ... information\r
    #   Exception will be raised if syntax error found\r
    #\r
    #   @param  self        The object pointer\r
    #\r
    def ParseFile(self):\r
\r
        try:\r
            self.__StringToList()\r
            self.PreprocessFile()\r
            self.PreprocessIncludeFile()\r
            self.__StringToList()\r
            self.PreprocessFile()\r
            self.PreprocessConditionalStatement()\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
            while self.__GetDefines():\r
                pass\r
            \r
            Index = 0\r
            while Index < len(self.Profile.FileLinesList):\r
                FileLineTuple = GetRealFileLine(self.FileName, Index + 1)\r
                self.Profile.FileLinesList[Index] = self.__ReplaceMacros(self.Profile.FileLinesList[Index], FileLineTuple[0], FileLineTuple[1])\r
                Index += 1\r
                \r
            while self.__GetFd():\r
                pass\r
\r
            while self.__GetFv():\r
                pass\r
\r
            while self.__GetCapsule():\r
                pass\r
\r
#            while self.__GetVtf():\r
#                pass\r
#\r
#            while self.__GetRule():\r
#                pass\r
            \r
\r
        except Warning, X:\r
            self.__UndoToken()\r
            FileLineTuple = GetRealFileLine(self.FileName, self.CurrentLineNumber)\r
            X.message += '\nGot Token: \"%s\" from File %s\n' % (self.__Token, FileLineTuple[0]) + \\r
                'Previous Token: \"%s\" At line: %d, Offset Within Line: %d\n' \\r
                    % (self.Profile.FileLinesList[self.CurrentLineNumber - 1][self.CurrentOffsetWithinLine :].rstrip('\n').rstrip('\r'), FileLineTuple[1], self.CurrentOffsetWithinLine)\r
            raise\r
\r
    ## __GetDefines() method\r
    #\r
    #   Get Defines section contents and store its data into AllMacrosList\r
    #\r
    #   @param  self        The object pointer\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
            return False\r
\r
        S = self.__Token.upper()\r
        if S.startswith("[") and not S.startswith("[DEFINES"):\r
            if 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."):\r
                raise Warning("Unknown section or section appear sequence error (The correct sequence should be [DEFINES], [FD.], [FV.], [Capsule.], [VTF.], [Rule.], [OptionRom.])", self.FileName, self.CurrentLineNumber)\r
            self.__UndoToken()\r
            return False\r
\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
            #        % (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
        if not self.__IsToken( "]"):\r
            raise Warning("expected ']'", self.FileName, self.CurrentLineNumber)\r
\r
        while self.__GetNextWord():\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
            FileLineTuple = GetRealFileLine(self.FileName, self.CurrentLineNumber)\r
            MacProfile = MacroProfile(FileLineTuple[0], FileLineTuple[1])\r
            MacProfile.MacroName = Macro\r
            MacProfile.MacroValue = Value\r
            AllMacroList.append(MacProfile)\r
\r
        return False\r
\r
    ## __GetFd() method\r
    #\r
    #   Get FD section contents and store its data into FD dictionary of self.Profile\r
    #\r
    #   @param  self        The object pointer\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
            return False\r
        \r
        S = self.__Token.upper()\r
        if S.startswith("[") and not S.startswith("[FD."):\r
            if not S.startswith("[FV.") and not S.startswith("[CAPSULE.") \\r
                and not S.startswith("[VTF.") and not S.startswith("[RULE."):\r
                raise Warning("Unknown section At Line ", self.FileName, self.CurrentLineNumber)\r
            self.__UndoToken()\r
            return False\r
        \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
                    % (self.Profile.FileLinesList[self.CurrentLineNumber - 1][self.CurrentOffsetWithinLine :], FileLineTuple[0], FileLineTuple[1], self.CurrentOffsetWithinLine)\r
            raise Warning("expected [FD.] At Line ", self.FileName, self.CurrentLineNumber)\r
        \r
        FdName = self.__GetUiName()\r
        self.CurrentFdName = FdName.upper()\r
        \r
        if not self.__IsToken( "]"):\r
            raise Warning("expected ']' At Line ", self.FileName, self.CurrentLineNumber)\r
        \r
        FdObj = CommonDataClass.FdfClass.FDClassObject()\r
        FdObj.FdUiName = self.CurrentFdName\r
        self.Profile.FdDict[self.CurrentFdName] = FdObj\r
        Status = self.__GetCreateFile(FdObj)\r
        if not Status:\r
            raise Warning("FD name error At Line ", self.FileName, self.CurrentLineNumber)\r
        \r
        if not self.__GetTokenStatements(FdObj):\r
            return False\r
        \r
        self.__GetDefineStatements(FdObj)\r
\r
        self.__GetSetStatements(FdObj)\r
\r
        if not self.__GetRegionLayout(FdObj):\r
            raise Warning("expected region layout At Line ", self.FileName, self.CurrentLineNumber)\r
            \r
        while self.__GetRegionLayout(FdObj):\r
            pass\r
        return True\r
    \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
    def __GetUiName(self):\r
        FdName = ""\r
        if self.__GetNextWord():\r
            FdName = self.__Token\r
            \r
        return FdName\r
\r
    ## __GetCreateFile() method\r
    #\r
    #   Return the output file name of object\r
    #\r
    #   @param  self        The object pointer\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 '=' At Line ", self.FileName, self.CurrentLineNumber)\r
                \r
            if not self.__GetNextToken():\r
                raise Warning("expected file name At Line ", self.FileName, self.CurrentLineNumber)\r
                \r
            FileName = self.__Token\r
            Obj.CreateFileName = FileName\r
\r
        return True\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
    #   @retval True        Successfully find a token statement\r
    #   @retval False       Not able to find a token statement\r
    #\r
    def __GetTokenStatements(self, Obj):\r
        if not self.__IsKeyword( "BaseAddress"):\r
            raise Warning("BaseAddress missing At Line ", self.FileName, self.CurrentLineNumber)\r
           \r
        if not self.__IsToken( "="):\r
            raise Warning("expected '=' At Line ", self.FileName, self.CurrentLineNumber)\r
            \r
        if not self.__GetNextHexNumber():\r
            raise Warning("expected Hex base address At Line ", self.FileName, self.CurrentLineNumber)\r
            \r
        Obj.BaseAddress = self.__Token\r
        \r
        if self.__IsToken( "|"):\r
            pcdPair = self.__GetNextPcdName()\r
            Obj.BaseAddressPcd = pcdPair\r
            self.Profile.PcdDict[pcdPair] = long(Obj.BaseAddress, 0)\r
            FileLineTuple = GetRealFileLine(self.FileName, self.CurrentLineNumber)\r
            self.Profile.PcdFileLineDict[pcdPair] = FileLineTuple\r
            \r
        if not self.__IsKeyword( "Size"):\r
            raise Warning("Size missing At Line ", self.FileName, self.CurrentLineNumber)\r
            \r
        if not self.__IsToken( "="):\r
            raise Warning("expected '=' At Line ", self.FileName, self.CurrentLineNumber)\r
            \r
        if not self.__GetNextHexNumber():\r
            raise Warning("expected Hex size At Line ", self.FileName, self.CurrentLineNumber)\r
            \r
      \r
        Obj.Size = long(self.__Token, 0)\r
\r
        if self.__IsToken( "|"):\r
            pcdPair = self.__GetNextPcdName()\r
            Obj.SizePcd = pcdPair\r
            self.Profile.PcdDict[pcdPair] = Obj.Size\r
            FileLineTuple = GetRealFileLine(self.FileName, self.CurrentLineNumber)\r
            self.Profile.PcdFileLineDict[pcdPair] = FileLineTuple\r
                    \r
        if not self.__IsKeyword( "ErasePolarity"):\r
            raise Warning("ErasePolarity missing At Line ", self.FileName, self.CurrentLineNumber)\r
           \r
        if not self.__IsToken( "="):\r
            raise Warning("expected '=' At Line ", self.FileName, self.CurrentLineNumber)\r
            \r
        if not self.__GetNextToken():\r
            raise Warning("expected Erase Polarity At Line ", self.FileName, self.CurrentLineNumber)\r
            \r
        if self.__Token != "1" and self.__Token != "0":\r
            raise Warning("expected 1 or 0 Erase Polarity At Line ", self.FileName, self.CurrentLineNumber)\r
            \r
        Obj.ErasePolarity = self.__Token\r
\r
        Status = self.__GetBlockStatements(Obj)\r
        return Status\r
    \r
    ## __GetAddressStatements() method\r
    #\r
    #   Get address statements\r
    #\r
    #   @param  self        The object pointer\r
    #   @param  Obj         for whom address statement is got\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 '=' At Line ", self.FileName, self.CurrentLineNumber)\r
            \r
            if not self.__GetNextDecimalNumber() and not self.__GetNextHexNumber():\r
                raise Warning("expected address At Line ", self.FileName, self.CurrentLineNumber)\r
                \r
            BsAddress = long(self.__Token, 0)\r
            Obj.BsBaseAddress = BsAddress\r
            \r
        if self.__IsKeyword("RtBaseAddress"):\r
            if not self.__IsToken( "="):\r
                raise Warning("expected '=' At Line ", self.FileName, self.CurrentLineNumber)\r
            \r
            if not self.__GetNextDecimalNumber() and not self.__GetNextHexNumber():\r
                raise Warning("expected address At Line ", self.FileName, self.CurrentLineNumber)\r
                \r
            RtAddress = long(self.__Token, 0)\r
            Obj.RtBaseAddress = RtAddress\r
    \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
    #   @retval True        Successfully find\r
    #   @retval False       Not able to find\r
    #\r
    def __GetBlockStatements(self, Obj):\r
        \r
        if not self.__GetBlockStatement(Obj):\r
            #set default block size is 1\r
            Obj.BlockSizeList.append((1, Obj.Size, None))\r
            return True\r
\r
        while self.__GetBlockStatement(Obj):\r
            pass\r
        \r
        for Item in Obj.BlockSizeList:\r
            if Item[0] is None or Item[1] is None:\r
                raise Warning("expected block statement for Fd Section", self.FileName, self.CurrentLineNumber)\r
\r
        return True\r
    \r
    ## __GetBlockStatement() method\r
    #\r
    #   Get block statement\r
    #\r
    #   @param  self        The object pointer\r
    #   @param  Obj         for whom block statement is got\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
            return False\r
        \r
        if not self.__IsToken( "="):\r
            raise Warning("expected '=' At Line ", self.FileName, self.CurrentLineNumber)\r
            \r
        if not self.__GetNextHexNumber() and not self.__GetNextDecimalNumber():\r
            raise Warning("expected Hex block size At Line ", self.FileName, self.CurrentLineNumber)\r
\r
        BlockSize = long(self.__Token, 0)\r
        BlockSizePcd = None\r
        if self.__IsToken( "|"):\r
            PcdPair = self.__GetNextPcdName()\r
            BlockSizePcd = PcdPair\r
            self.Profile.PcdDict[PcdPair] = BlockSize\r
            FileLineTuple = GetRealFileLine(self.FileName, self.CurrentLineNumber)\r
            self.Profile.PcdFileLineDict[pcdPair] = FileLineTuple\r
            \r
        BlockNumber = None\r
        if self.__IsKeyword( "NumBlocks"):\r
            if not self.__IsToken( "="):\r
                raise Warning("expected '=' At Line ", self.FileName, self.CurrentLineNumber)\r
                \r
            if not self.__GetNextDecimalNumber() and not self.__GetNextHexNumber():\r
                raise Warning("expected block numbers At Line ", self.FileName, self.CurrentLineNumber)\r
                \r
            BlockNumber = long(self.__Token, 0)\r
        \r
        Obj.BlockSizeList.append((BlockSize, BlockNumber, BlockSizePcd))\r
        return True\r
\r
    ## __GetDefineStatements() method\r
    #\r
    #   Get define statements\r
    #\r
    #   @param  self        The object pointer\r
    #   @param  Obj         for whom define statement is got\r
    #   @retval True        Successfully find\r
    #   @retval False       Not able to find\r
    #\r
    def __GetDefineStatements(self, Obj):\r
        while self.__GetDefineStatement( Obj):\r
            pass\r
    \r
    ## __GetDefineStatement() method\r
    #\r
    #   Get define statement\r
    #\r
    #   @param  self        The object pointer\r
    #   @param  Obj         for whom define statement is got\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 '=' At Line ", self.FileName, self.CurrentLineNumber)\r
                \r
            if not self.__GetNextToken():\r
                raise Warning("expected value At Line ", self.FileName, self.CurrentLineNumber)\r
\r
            Value = self.__Token\r
            Macro = '$(' + Macro + ')'\r
            Obj.DefineVarDict[Macro] = Value\r
            return True\r
        \r
        return False\r
    \r
    ## __GetSetStatements() method\r
    #\r
    #   Get set statements\r
    #\r
    #   @param  self        The object pointer\r
    #   @param  Obj         for whom set statement is got\r
    #   @retval True        Successfully find\r
    #   @retval False       Not able to find\r
    #\r
    def __GetSetStatements(self, Obj):\r
        while self.__GetSetStatement(Obj):\r
            pass\r
\r
    ## __GetSetStatement() method\r
    #\r
    #   Get set statement\r
    #\r
    #   @param  self        The object pointer\r
    #   @param  Obj         for whom set statement is got\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
            \r
            if not self.__IsToken( "="):\r
                raise Warning("expected '=' At Line ", self.FileName, self.CurrentLineNumber)\r
                \r
            if not self.__GetNextToken():\r
                raise Warning("expected value At Line ", self.FileName, self.CurrentLineNumber)\r
                \r
            Value = self.__Token\r
            if Value.startswith("{"):\r
                # deal with value with {}\r
                if not self.__SkipToToken( "}"):\r
                    raise Warning("expected '}' At Line ", self.FileName, self.CurrentLineNumber)\r
                Value += self.__SkippedChars\r
                \r
            Obj.SetVarDict[PcdPair] = Value\r
            self.Profile.PcdDict[PcdPair] = Value\r
            FileLineTuple = GetRealFileLine(self.FileName, self.CurrentLineNumber)\r
            self.Profile.PcdFileLineDict[PcdPair] = FileLineTuple\r
            return True\r
\r
        return False\r
\r
    ## __GetRegionLayout() method\r
    #\r
    #   Get region layout for FD\r
    #\r
    #   @param  self        The object pointer\r
    #   @param  Fd          for whom region is got\r
    #   @retval True        Successfully find\r
    #   @retval False       Not able to find\r
    #\r
    def __GetRegionLayout(self, Fd):\r
        if not self.__GetNextHexNumber():\r
            return False\r
        \r
        RegionObj = CommonDataClass.FdfClass.RegionClassObject()\r
        RegionObj.Offset = long(self.__Token, 0)\r
        Fd.RegionList.append(RegionObj)\r
        \r
        if not self.__IsToken( "|"):\r
            raise Warning("expected '|' At Line ", self.FileName, self.CurrentLineNumber)\r
        \r
        if not self.__GetNextHexNumber():\r
            raise Warning("expected Region Size At Line ", self.FileName, self.CurrentLineNumber)\r
        RegionObj.Size = long(self.__Token, 0)\r
        \r
        if not self.__GetNextWord():\r
            return True\r
        \r
        if not self.__Token in ("SET", "FV", "FILE", "DATA", "CAPSULE"):\r
            self.__UndoToken()\r
            RegionObj.PcdOffset = self.__GetNextPcdName()\r
            self.Profile.PcdDict[RegionObj.PcdOffset] = RegionObj.Offset + long(Fd.BaseAddress, 0)\r
            FileLineTuple = GetRealFileLine(self.FileName, self.CurrentLineNumber)\r
            self.Profile.PcdFileLineDict[RegionObj.PcdOffset] = FileLineTuple\r
            if self.__IsToken( "|"):\r
                RegionObj.PcdSize = self.__GetNextPcdName()\r
                self.Profile.PcdDict[RegionObj.PcdSize] = RegionObj.Size\r
                FileLineTuple = GetRealFileLine(self.FileName, self.CurrentLineNumber)\r
                self.Profile.PcdFileLineDict[RegionObj.PcdSize] = FileLineTuple\r
            \r
            if not self.__GetNextWord():\r
                return True\r
\r
        if self.__Token == "SET":\r
            self.__UndoToken()\r
            self.__GetSetStatements( RegionObj)\r
            if not self.__GetNextWord():\r
                return True\r
            \r
        elif self.__Token == "FV":\r
            self.__UndoToken()\r
            self.__GetRegionFvType( RegionObj)\r
\r
        elif self.__Token == "CAPSULE":\r
            self.__UndoToken()\r
            self.__GetRegionCapType( RegionObj)\r
\r
        elif self.__Token == "FILE":\r
            self.__UndoToken()\r
            self.__GetRegionFileType( RegionObj)\r
\r
        else:\r
            self.__UndoToken()\r
            self.__GetRegionDataType( RegionObj)\r
            \r
        return True\r
            \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
    def __GetRegionFvType(self, RegionObj):\r
\r
        if not self.__IsKeyword( "FV"):\r
            raise Warning("expected Keyword 'FV' At Line ", self.FileName, self.CurrentLineNumber)\r
        \r
        if not self.__IsToken( "="):\r
            raise Warning("expected '=' At Line ", self.FileName, self.CurrentLineNumber)\r
        \r
        if not self.__GetNextToken():\r
            raise Warning("expected FV name At Line ", self.FileName, self.CurrentLineNumber)\r
        \r
        RegionObj.RegionType = "FV"\r
        RegionObj.RegionDataList.append(self.__Token)\r
        \r
        while self.__IsKeyword( "FV"):\r
        \r
            if not self.__IsToken( "="):\r
                raise Warning("expected '=' At Line ", self.FileName, self.CurrentLineNumber)\r
        \r
            if not self.__GetNextToken():\r
                raise Warning("expected FV name At Line ", self.FileName, self.CurrentLineNumber)\r
        \r
            RegionObj.RegionDataList.append(self.__Token)\r
\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
    def __GetRegionCapType(self, RegionObj):\r
\r
        if not self.__IsKeyword("CAPSULE"):\r
            raise Warning("expected Keyword 'CAPSULE' at line", self.FileName, self.CurrentLineNumber)\r
\r
        if not self.__IsToken("="):\r
            raise Warning("expected '=' at line", self.FileName, self.CurrentLineNumber)\r
\r
        if not self.__GetNextToken():\r
            raise Warning("expected CAPSULE name at line", self.FileName, self.CurrentLineNumber)\r
\r
        RegionObj.RegionType = "CAPSULE"\r
        RegionObj.RegionDataList.append(self.__Token)\r
\r
        while self.__IsKeyword("CAPSULE"):\r
\r
            if not self.__IsToken("="):\r
                raise Warning("expected '=' at line", self.FileName, self.CurrentLineNumber)\r
\r
            if not self.__GetNextToken():\r
                raise Warning("expected CAPSULE name at line", self.FileName, self.CurrentLineNumber)\r
\r
            RegionObj.RegionDataList.append(self.__Token)\r
\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
    def __GetRegionFileType(self, RegionObj):\r
\r
        if not self.__IsKeyword( "FILE"):\r
            raise Warning("expected Keyword 'FILE' At Line ", self.FileName, self.CurrentLineNumber)\r
\r
        if not self.__IsToken( "="):\r
            raise Warning("expected '=' At Line ", self.FileName, self.CurrentLineNumber)\r
\r
        if not self.__GetNextToken():\r
            raise Warning("expected File name At Line ", self.FileName, self.CurrentLineNumber)\r
\r
        RegionObj.RegionType = "FILE"\r
        RegionObj.RegionDataList.append( self.__Token)\r
        \r
        while self.__IsKeyword( "FILE"):\r
        \r
            if not self.__IsToken( "="):\r
                raise Warning("expected '=' At Line ", self.FileName, self.CurrentLineNumber)\r
        \r
            if not self.__GetNextToken():\r
                raise Warning("expected FILE name At Line ", self.FileName, self.CurrentLineNumber)\r
        \r
            RegionObj.RegionDataList.append(self.__Token)\r
\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
    def __GetRegionDataType(self, RegionObj):\r
        \r
        if not self.__IsKeyword( "DATA"):\r
            raise Warning("expected Region Data type At Line ", self.FileName, self.CurrentLineNumber)\r
\r
        if not self.__IsToken( "="):\r
            raise Warning("expected '=' At Line ", self.FileName, self.CurrentLineNumber)\r
        \r
        if not self.__IsToken( "{"):\r
            raise Warning("expected '{' At Line ", self.FileName, self.CurrentLineNumber)\r
        \r
        if not self.__GetNextHexNumber():\r
            raise Warning("expected Hex byte At Line ", self.FileName, self.CurrentLineNumber)\r
        \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
        DataString = self.__Token\r
        DataString += ","\r
        \r
        while self.__IsToken(","):\r
            if not self.__GetNextHexNumber():\r
                raise Warning("Invalid Hex number At Line ", self.FileName, self.CurrentLineNumber)\r
            if len(self.__Token) > 4:\r
                raise Warning("Hex byte(must be 2 digits) too long At Line ", self.FileName, self.CurrentLineNumber)\r
            DataString += self.__Token\r
            DataString += ","\r
            \r
        if not self.__IsToken( "}"):\r
            raise Warning("expected '}' At Line ", self.FileName, self.CurrentLineNumber)\r
        \r
        DataString = DataString.rstrip(",")\r
        RegionObj.RegionType = "DATA"\r
        RegionObj.RegionDataList.append( DataString)\r
        \r
        while self.__IsKeyword( "DATA"):\r
\r
            if not self.__IsToken( "="):\r
                raise Warning("expected '=' At Line ", self.FileName, self.CurrentLineNumber)\r
        \r
            if not self.__IsToken( "{"):\r
                raise Warning("expected '{' At Line ", self.FileName, self.CurrentLineNumber)\r
        \r
            if not self.__GetNextHexNumber():\r
                raise Warning("expected Hex byte At Line ", self.FileName, self.CurrentLineNumber)\r
        \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
            DataString = self.__Token\r
            DataString += ","\r
        \r
            while self.__IsToken(","):\r
                self.__GetNextHexNumber()\r
                if len(self.__Token) > 4:\r
                    raise Warning("Hex byte(must be 2 digits) too long At Line ", self.FileName, self.CurrentLineNumber)\r
                DataString += self.__Token\r
                DataString += ","\r
            \r
            if not self.__IsToken( "}"):\r
                raise Warning("expected '}' At Line ", self.FileName, self.CurrentLineNumber)\r
        \r
            DataString = DataString.rstrip(",")\r
            RegionObj.RegionDataList.append( DataString)\r
    \r
    ## __GetFv() method\r
    #\r
    #   Get FV section contents and store its data into FV dictionary of self.Profile\r
    #\r
    #   @param  self        The object pointer\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
            return False\r
\r
        S = self.__Token.upper()\r
        if S.startswith("[") and not S.startswith("[FV."):\r
            if not S.startswith("[CAPSULE.") \\r
                and not S.startswith("[VTF.") and not S.startswith("[RULE."):\r
                raise Warning("Unknown section or section appear sequence error \n(The correct sequence should be [FD.], [FV.], [Capsule.], [VTF.], [Rule.]) At Line ", self.FileName, self.CurrentLineNumber)\r
            self.__UndoToken()\r
            return False\r
\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
                    % (self.Profile.FileLinesList[self.CurrentLineNumber - 1][self.CurrentOffsetWithinLine :], FileLineTuple[0], FileLineTuple[1], self.CurrentOffsetWithinLine)\r
            raise Warning("Unknown Keyword At Line ", self.FileName, self.CurrentLineNumber)\r
        \r
        FvName = self.__GetUiName()\r
        self.CurrentFvName = FvName.upper()\r
        \r
        if not self.__IsToken( "]"):\r
            raise Warning("expected ']' At Line ", self.FileName, self.CurrentLineNumber)\r
        \r
        FvObj = CommonDataClass.FdfClass.FvClassObject()\r
        FvObj.UiFvName = self.CurrentFvName\r
        self.Profile.FvDict[self.CurrentFvName] = FvObj\r
        \r
        Status = self.__GetCreateFile(FvObj)\r
        if not Status:\r
            raise Warning("FV name error At Line ", self.FileName, self.CurrentLineNumber)\r
\r
        self.__GetDefineStatements(FvObj)\r
\r
        self.__GetAddressStatements(FvObj)\r
        \r
        self.__GetBlockStatement(FvObj)\r
\r
        self.__GetSetStatements(FvObj)\r
\r
        self.__GetFvAlignment(FvObj)\r
\r
        self.__GetFvAttributes(FvObj)\r
        \r
        self.__GetFvNameGuid(FvObj)\r
\r
        self.__GetAprioriSection(FvObj, FvObj.DefineVarDict.copy())\r
        self.__GetAprioriSection(FvObj, FvObj.DefineVarDict.copy())\r
        \r
        while True:\r
            isInf = self.__GetInfStatement(FvObj, MacroDict = FvObj.DefineVarDict.copy())\r
            isFile = self.__GetFileStatement(FvObj, MacroDict = FvObj.DefineVarDict.copy())\r
            if not isInf and not isFile:\r
                break\r
        \r
        return True\r
\r
    ## __GetFvAlignment() method\r
    #\r
    #   Get alignment for FV\r
    #\r
    #   @param  self        The object pointer\r
    #   @param  Obj         for whom alignment is got\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
            return False\r
        \r
        if not self.__IsToken( "="):\r
            raise Warning("expected '=' At Line ", self.FileName, self.CurrentLineNumber)\r
        \r
        if not self.__GetNextToken():\r
            raise Warning("expected alignment value At Line ", self.FileName, self.CurrentLineNumber)\r
        \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
                                        "1G", "2G"):\r
            raise Warning("Unknown alignment value At Line ", self.FileName, self.CurrentLineNumber)\r
        Obj.FvAlignment = self.__Token\r
        return True\r
    \r
    ## __GetFvAttributes() method\r
    #\r
    #   Get attributes for FV\r
    #\r
    #   @param  self        The object pointer\r
    #   @param  Obj         for whom attribute is got\r
    #   @retval None\r
    #\r
    def __GetFvAttributes(self, FvObj):\r
        \r
        while self.__GetNextWord():\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
                           "WRITE_POLICY_RELIABLE"):\r
                self.__UndoToken()\r
                return\r
\r
            if not self.__IsToken( "="):\r
                raise Warning("expected '=' At Line ", self.FileName, self.CurrentLineNumber)\r
            \r
            if not self.__GetNextToken() or self.__Token.upper() not in ("TRUE", "FALSE", "1", "0"):\r
                raise Warning("expected TRUE/FALSE (1/0) At Line ", self.FileName, self.CurrentLineNumber)\r
            \r
            FvObj.FvAttributeDict[name] = self.__Token\r
\r
        return\r
    \r
    ## __GetFvNameGuid() method\r
    #\r
    #   Get FV GUID for FV\r
    #\r
    #   @param  self        The object pointer\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
            return\r
\r
        if not self.__IsToken( "="):\r
            raise Warning("expected '='", self.FileName, self.CurrentLineNumber)\r
\r
        if not self.__GetNextGuid():\r
            raise Warning("expected FV GUID value", self.FileName, self.CurrentLineNumber)\r
\r
        FvObj.FvNameGuid = self.__Token\r
\r
        return\r
\r
    ## __GetAprioriSection() method\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
    def __GetAprioriSection(self, FvObj, MacroDict = {}):\r
        \r
        if not self.__IsKeyword( "APRIORI"):\r
            return False\r
        \r
        if not self.__IsKeyword("PEI") and not self.__IsKeyword("DXE"):\r
            raise Warning("expected Apriori file type At Line ", self.FileName, self.CurrentLineNumber)\r
        AprType = self.__Token\r
        \r
        if not self.__IsToken( "{"):\r
            raise Warning("expected '{' At Line ", self.FileName, self.CurrentLineNumber)\r
        \r
        AprSectionObj = CommonDataClass.FdfClass.AprioriSectionClassObject()\r
        AprSectionObj.AprioriType = AprType\r
        \r
        self.__GetDefineStatements(AprSectionObj)\r
        MacroDict.update(AprSectionObj.DefineVarDict)\r
        \r
        while True:\r
            IsInf = self.__GetInfStatement( AprSectionObj, MacroDict = MacroDict)\r
            IsFile = self.__GetFileStatement( AprSectionObj)\r
            if not IsInf and not IsFile:\r
                break\r
        \r
        if not self.__IsToken( "}"):\r
            raise Warning("expected '}' At Line ", self.FileName, self.CurrentLineNumber)\r
\r
        FvObj.AprioriSectionList.append(AprSectionObj)\r
        return True\r
\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
    #   @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
    def __GetInfStatement(self, Obj, ForCapsule = False, MacroDict = {}):\r
\r
        if not self.__IsKeyword( "INF"):\r
            return False\r
        \r
        ffsInf = CommonDataClass.FdfClass.FfsInfStatementClassObject()\r
        self.__GetInfOptions( ffsInf)\r
        \r
        if not self.__GetNextToken():\r
            raise Warning("expected INF file path At Line ", self.FileName, self.CurrentLineNumber)\r
        ffsInf.InfFileName = self.__Token\r
        \r
#        if ffsInf.InfFileName.find('$') >= 0:\r
#            ffsInf.InfFileName = GenFdsGlobalVariable.GenFdsGlobalVariable.MacroExtend(ffsInf.InfFileName, MacroDict)\r
            \r
        if not ffsInf.InfFileName in self.Profile.InfList:\r
            self.Profile.InfList.append(ffsInf.InfFileName)\r
            FileLineTuple = GetRealFileLine(self.FileName, self.CurrentLineNumber)\r
            self.Profile.InfFileLineList.append(FileLineTuple)\r
        \r
        if self.__IsToken('|'):\r
            if self.__IsKeyword('RELOCS_STRIPPED'):\r
                ffsInf.KeepReloc = False\r
            elif self.__IsKeyword('RELOCS_RETAINED'):\r
                ffsInf.KeepReloc = True\r
            else:\r
                raise Warning("Unknown reloc strip flag At Line ", self.FileName, self.CurrentLineNumber)\r
        \r
        if ForCapsule:\r
            capsuleFfs = CapsuleData.CapsuleFfs()\r
            capsuleFfs.Ffs = ffsInf\r
            Obj.CapsuleDataList.append(capsuleFfs)\r
        else:\r
            Obj.FfsList.append(ffsInf)\r
        return True\r
    \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
    def __GetInfOptions(self, FfsInfObj):\r
        \r
        if self.__IsKeyword( "RuleOverride"):\r
            if not self.__IsToken( "="):\r
                raise Warning("expected '=' At Line ", self.FileName, self.CurrentLineNumber)\r
            if not self.__GetNextToken():\r
                raise Warning("expected Rule name At Line ", self.FileName, self.CurrentLineNumber)\r
            FfsInfObj.Rule = self.__Token\r
            \r
        if self.__IsKeyword( "VERSION"):\r
            if not self.__IsToken( "="):\r
                raise Warning("expected '=' At Line ", self.FileName, self.CurrentLineNumber)\r
            if not self.__GetNextToken():\r
                raise Warning("expected Version At Line ", 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 '=' At Line ", self.FileName, self.CurrentLineNumber)\r
            if not self.__GetNextToken():\r
                raise Warning("expected UI name At Line ", 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
            if TokenFindPattern.match(self.__Token):\r
                FfsInfObj.KeyStringList.append(self.__Token)\r
                if not self.__IsToken(","):\r
                    return\r
            else:\r
                self.__UndoToken()\r
                return\r
                \r
            while self.__GetNextToken():\r
                if not TokenFindPattern.match(self.__Token):\r
                    raise Warning("expected KeyString \"Target_Tag_Arch\" At Line ", self.FileName, self.CurrentLineNumber)\r
                FfsInfObj.KeyStringList.append(self.__Token)\r
    \r
                if not self.__IsToken(","):\r
                    break\r
                \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
    #   @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
    def __GetFileStatement(self, Obj, ForCapsule = False, MacroDict = {}):\r
\r
        if not self.__IsKeyword( "FILE"):\r
            return False\r
        \r
        FfsFileObj = CommonDataClass.FdfClass.FileStatementClassObject()\r
        \r
        if not self.__GetNextWord():\r
            raise Warning("expected FFS type At Line ", self.FileName, self.CurrentLineNumber)\r
        FfsFileObj.FvFileType = self.__Token\r
        \r
        if not self.__IsToken( "="):\r
            raise Warning("expected '=' At Line ", 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
        if ForCapsule:\r
            capsuleFfs = CapsuleData.CapsuleFfs()\r
            capsuleFfs.Ffs = FfsFileObj\r
            Obj.CapsuleDataList.append(capsuleFfs)\r
        else:\r
            Obj.FfsList.append(FfsFileObj)\r
                \r
        return True\r
    \r
    ## __FileCouldHaveRelocFlag() method\r
    #\r
    #   Check whether reloc strip flag can be set for a file type.\r
    #\r
    #   @param  self        The object pointer\r
    #   @param  FileType    The file type to check with\r
    #   @retval True        This type could have relocation strip flag\r
    #   @retval False       No way to have it\r
    #\r
    \r
    def __FileCouldHaveRelocFlag (self, FileType):\r
        if FileType in ('SEC', 'PEI_CORE', 'PEIM', 'PEI_DXE_COMBO'):\r
            return True\r
        else:\r
            return False\r
    \r
    ## __SectionCouldHaveRelocFlag() method\r
    #\r
    #   Check whether reloc strip flag can be set for a section type.\r
    #\r
    #   @param  self        The object pointer\r
    #   @param  SectionType The section type to check with\r
    #   @retval True        This type could have relocation strip flag\r
    #   @retval False       No way to have it\r
    #\r
    \r
    def __SectionCouldHaveRelocFlag (self, SectionType):\r
        if SectionType in ('TE', 'PE32'):\r
            return True\r
        else:\r
            return False\r
        \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
    #   @param  MacroDict   dictionary used to replace macro\r
    #\r
    def __GetFilePart(self, FfsFileObj, MacroDict = {}):\r
        \r
        self.__GetFileOpts( FfsFileObj)\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
#                        FfsFileObj.KeepReloc = False\r
#                    else:\r
#                        FfsFileObj.KeepReloc = True\r
#                else:\r
#                    raise Warning("File type %s could not have reloc strip flag At Line %d" % (FfsFileObj.FvFileType, self.CurrentLineNumber), self.FileName, self.CurrentLineNumber)\r
#            \r
#            if not self.__IsToken("{"):\r
            raise Warning("expected '{' At Line ", self.FileName, self.CurrentLineNumber)\r
            \r
        if not self.__GetNextToken():\r
            raise Warning("expected File name or section data At Line ", self.FileName, self.CurrentLineNumber)\r
        \r
        if self.__Token == "FV":\r
            if not self.__IsToken( "="):\r
                raise Warning("expected '=' At Line ", self.FileName, self.CurrentLineNumber)\r
            if not self.__GetNextToken():\r
                raise Warning("expected FV name At Line ", self.FileName, self.CurrentLineNumber)\r
            FfsFileObj.FvName = self.__Token\r
            \r
        elif self.__Token == "FD":\r
            if not self.__IsToken( "="):\r
                raise Warning("expected '=' At Line ", self.FileName, self.CurrentLineNumber)\r
            if not self.__GetNextToken():\r
                raise Warning("expected FD name At Line ", self.FileName, self.CurrentLineNumber)\r
            FfsFileObj.FdName = self.__Token\r
            \r
        elif self.__Token in ("DEFINE", "APRIORI", "SECTION"):\r
            self.__UndoToken()\r
            self.__GetSectionData( FfsFileObj, MacroDict)\r
        else:\r
            FfsFileObj.FileName = self.__Token\r
        \r
        if not self.__IsToken( "}"):\r
            raise Warning("expected '}' At Line ", self.FileName, self.CurrentLineNumber)\r
    \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
    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\" At Line ", self.FileName, self.CurrentLineNumber)\r
                        FfsFileObj.KeyStringList.append(self.__Token)\r
\r
                        if not self.__IsToken(","):\r
                            break\r
                    \r
            else:\r
                self.__UndoToken()\r
\r
        if self.__IsKeyword( "FIXED", True):\r
            FfsFileObj.Fixed = True\r
            \r
        if self.__IsKeyword( "CHECKSUM", True):\r
            FfsFileObj.CheckSum = True\r
            \r
        if self.__GetAlignment():\r
            FfsFileObj.Alignment = self.__Token\r
            \r
        \r
    \r
    ## __GetAlignment() method\r
    #\r
    #   Return the alignment value\r
    #\r
    #   @param  self        The object pointer\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 '=' At Line ", self.FileName, self.CurrentLineNumber)\r
            \r
            if not self.__GetNextToken():\r
                raise Warning("expected alignment value At Line ", self.FileName, self.CurrentLineNumber)\r
            return True\r
            \r
        return False\r
    \r
    ## __GetFilePart() 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
    #   @param  MacroDict   dictionary used to replace macro\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
        \r
        while True:\r
            IsLeafSection = self.__GetLeafSection(FfsFileObj, Dict)\r
            IsEncapSection = self.__GetEncapsulationSec(FfsFileObj)\r
            if not IsLeafSection and not IsEncapSection:\r
                break\r
         \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
    #   @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
    def __GetLeafSection(self, Obj, MacroDict = {}):\r
        \r
        OldPos = self.GetFileBufferPos()\r
        \r
        if not self.__IsKeyword( "SECTION"):\r
            if len(Obj.SectionList) == 0:\r
                raise Warning("expected SECTION At Line ", self.FileName, self.CurrentLineNumber)\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
            \r
        BuildNum = None\r
        if self.__IsKeyword( "BUILD_NUM"):\r
            if not self.__IsToken( "="):\r
                raise Warning("expected '=' At Line ", self.FileName, self.CurrentLineNumber)\r
            \r
            if not self.__GetNextToken():\r
                raise Warning("expected Build number value At Line ", self.FileName, self.CurrentLineNumber)\r
            \r
            BuildNum = self.__Token\r
            \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 not self.__IsToken( "="):\r
                raise Warning("expected '=' At Line ", self.FileName, self.CurrentLineNumber)\r
            if not self.__GetNextToken():\r
                raise Warning("expected version At Line ", self.FileName, self.CurrentLineNumber)\r
            VerSectionObj = CommonDataClass.FdfClass.VerSectionClassObject()\r
            VerSectionObj.Alignment = AlignValue\r
            VerSectionObj.BuildNum = BuildNum\r
            if self.__GetStringData():\r
                VerSectionObj.StringData = self.__Token\r
            else:\r
                VerSectionObj.FileName = self.__Token\r
            Obj.SectionList.append(VerSectionObj)\r
\r
        elif self.__IsKeyword( "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 not self.__IsToken( "="):\r
                raise Warning("expected '=' At Line ", self.FileName, self.CurrentLineNumber)\r
            if not self.__GetNextToken():\r
                raise Warning("expected UI At Line ", self.FileName, self.CurrentLineNumber)\r
            UiSectionObj = CommonDataClass.FdfClass.UiSectionClassObject()\r
            UiSectionObj.Alignment = AlignValue\r
            if self.__GetStringData():\r
                UiSectionObj.StringData = self.__Token\r
            else:\r
                UiSectionObj.FileName = self.__Token\r
            Obj.SectionList.append(UiSectionObj)\r
            \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 not self.__IsToken( "="):\r
                raise Warning("expected '=' At Line ", self.FileName, self.CurrentLineNumber)\r
            if not self.__GetNextWord():\r
                raise Warning("expected FV name At Line ", self.FileName, self.CurrentLineNumber)\r
            \r
            FvName = self.__Token.upper()\r
            FvObj = None\r
\r
            if self.__IsToken( "{"):\r
                FvObj = Fv.FV()\r
                FvObj.UiFvName = FvName\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
    \r
                while True:\r
                    IsInf = self.__GetInfStatement(FvObj, MacroDict.copy())\r
                    IsFile = self.__GetFileStatement(FvObj, MacroDict.copy())\r
                    if not IsInf and not IsFile:\r
                        break\r
    \r
                if not self.__IsToken( "}"):\r
                    raise Warning("expected '}' At Line ", self.FileName, self.CurrentLineNumber)\r
            \r
            FvImageSectionObj = CommonDataClass.FdfClass.FvImageSectionClassObject()\r
            FvImageSectionObj.Alignment = AlignValue\r
            if FvObj is not None:\r
                FvImageSectionObj.Fv = FvObj\r
                FvImageSectionObj.FvName = None\r
            else:\r
                FvImageSectionObj.FvName = FvName\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
            if AlignValue == 'Auto':\r
                raise Warning("Auto alignment can only be used in PE32 or TE section ", self.FileName, self.CurrentLineNumber)\r
            DepexSectionObj = CommonDataClass.FdfClass.DepexSectionClassObject()\r
            DepexSectionObj.Alignment = AlignValue\r
            DepexSectionObj.DepexType = self.__Token\r
            \r
            if not self.__IsToken( "="):\r
                raise Warning("expected '=' At Line ", self.FileName, self.CurrentLineNumber)\r
            if not self.__IsToken( "{"):\r
                raise Warning("expected '{' At Line ", self.FileName, self.CurrentLineNumber)\r
            if not self.__SkipToToken( "}"):\r
                raise Warning("expected Depex expression ending '}' At Line ", self.FileName, self.CurrentLineNumber)\r
            \r
            DepexSectionObj.Expression = self.__SkippedChars.rstrip('}')\r
            Obj.SectionList.append(DepexSectionObj)\r
        \r
        else:\r
            \r
            if not self.__GetNextWord():\r
                raise Warning("expected section type At Line ", self.FileName, self.CurrentLineNumber)\r
            \r
            # Encapsulation section appear, UndoToken and return\r
            if self.__Token == "COMPRESS" or self.__Token == "GUIDED":\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
                raise Warning("Auto alignment can only be used in PE32 or TE section ", self.FileName, self.CurrentLineNumber)\r
            # DataSection\r
            DataSectionObj = CommonDataClass.FdfClass.DataSectionClassObject()\r
            DataSectionObj.Alignment = AlignValue\r
            DataSectionObj.SecType = self.__Token\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
                        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 At Line %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 At Line ", self.FileName, self.CurrentLineNumber)\r
                DataSectionObj.SectFileName = self.__Token\r
            else:\r
                if not self.__GetCglSection(DataSectionObj):\r
                    return False\r
            \r
            Obj.SectionList.append(DataSectionObj)\r
            \r
        return True\r
            \r
    ## __GetCglSection() method\r
    #\r
    #   Get compressed or GUIDed section for Obj\r
    #\r
    #   @param  self        The object pointer\r
    #   @param  Obj         for whom leaf section is got\r
    #   @param  AlignValue  alignment value for complex section\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
        \r
        if self.__IsKeyword( "COMPRESS"):\r
            type = "PI_STD"\r
            if self.__IsKeyword("PI_STD") or self.__IsKeyword("PI_NONE"):\r
                type = self.__Token\r
                \r
            if not self.__IsToken("{"):\r
                raise Warning("expected '{' At Line ", self.FileName, self.CurrentLineNumber)\r
\r
            CompressSectionObj = CommonDataClass.FdfClass.CompressSectionClassObject()\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
                if not IsLeafSection and not IsEncapSection:\r
                    break\r
            \r
            \r
            if not self.__IsToken( "}"):\r
                raise Warning("expected '}' At Line ", self.FileName, self.CurrentLineNumber)\r
            Obj.SectionList.append(CompressSectionObj)\r
                \r
#            else:\r
#               raise Warning("Compress type not known At Line ") \r
           \r
            return True\r
        \r
        elif self.__IsKeyword( "GUIDED"):\r
            GuidValue = None\r
            if self.__GetNextGuid():\r
                GuidValue = self.__Token\r
\r
            AttribDict = self.__GetGuidAttrib()\r
            if not self.__IsToken("{"):\r
                raise Warning("expected '{' At Line ", self.FileName, self.CurrentLineNumber)\r
            GuidSectionObj = CommonDataClass.FdfClass.GuidSectionClassObject()\r
            GuidSectionObj.Alignment = AlignValue\r
            GuidSectionObj.NameGuid = GuidValue\r
            GuidSectionObj.SectionType = "GUIDED"\r
            GuidSectionObj.ProcessRequired = AttribDict["PROCESSING_REQUIRED"]\r
            GuidSectionObj.AuthStatusValid = AttribDict["AUTH_STATUS_VALID"]\r
            # Recursive sections...\r
            while True:\r
                IsLeafSection = self.__GetLeafSection(GuidSectionObj)\r
                IsEncapSection = self.__GetEncapsulationSec(GuidSectionObj)\r
                if not IsLeafSection and not IsEncapSection:\r
                    break\r
            \r
            if not self.__IsToken( "}"):\r
                raise Warning("expected '}' At Line ", self.FileName, self.CurrentLineNumber)\r
            Obj.SectionList.append(GuidSectionObj)\r
                \r
            return True\r
        \r
        return False\r
\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
    def __GetGuidAttrib(self):\r
        \r
        AttribDict = {}\r
        AttribDict["PROCESSING_REQUIRED"] = False\r
        AttribDict["AUTH_STATUS_VALID"] = False\r
        if self.__IsKeyword("PROCESSING_REQUIRED") or self.__IsKeyword("AUTH_STATUS_VALID"):\r
            AttribKey = self.__Token\r
\r
            if not self.__IsToken("="):\r
                raise Warning("expected '=' At Line ", self.FileName, self.CurrentLineNumber)\r
            \r
            if not self.__GetNextToken() or self.__Token.upper() not in ("TRUE", "FALSE", "1", "0"):\r
                raise Warning("expected TRUE/FALSE (1/0) At Line ", self.FileName, self.CurrentLineNumber)\r
            AttribDict[AttribKey] = self.__Token\r
            \r
        if self.__IsKeyword("PROCESSING_REQUIRED") or self.__IsKeyword("AUTH_STATUS_VALID"):\r
            AttribKey = self.__Token\r
\r
            if not self.__IsToken("="):\r
                raise Warning("expected '=' At Line ")\r
\r
            if not self.__GetNextToken() or self.__Token.upper() not in ("TRUE", "FALSE", "1", "0"):\r
                raise Warning("expected TRUE/FALSE (1/0) At Line ", self.FileName, self.CurrentLineNumber)\r
            AttribDict[AttribKey] = self.__Token\r
            \r
        return AttribDict\r
            \r
    ## __GetEncapsulationSec() method\r
    #\r
    #   Get encapsulation section for FILE\r
    #\r
    #   @param  self        The object pointer\r
    #   @param  FfsFile     for whom section is got\r
    #   @retval True        Successfully find section statement\r
    #   @retval False       Not able to find section statement\r
    #\r
    def __GetEncapsulationSec(self, FfsFileObj):        \r
        \r
        OldPos = self.GetFileBufferPos()\r
        if not self.__IsKeyword( "SECTION"):\r
            if len(FfsFileObj.SectionList) == 0:\r
                raise Warning("expected SECTION At Line ", self.FileName, self.CurrentLineNumber)\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
            \r
        if not self.__GetCglSection(FfsFileObj, AlignValue):\r
            self.SetFileBufferPos(OldPos)\r
            return False\r
        else:\r
            return True\r
\r
    ## __GetCapsule() method\r
    #\r
    #   Get capsule section contents and store its data into capsule list of self.Profile\r
    #\r
    #   @param  self        The object pointer\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
            return False\r
\r
        S = self.__Token.upper()\r
        if S.startswith("[") and not S.startswith("[CAPSULE."):\r
            if not S.startswith("[VTF.") and not S.startswith("[RULE.") and not S.startswith("[OPTIONROM."):\r
                raise Warning("Unknown section or section appear sequence error (The correct sequence should be [FD.], [FV.], [Capsule.], [VTF.], [Rule.], [OptionRom.])", self.FileName, self.CurrentLineNumber)\r
            self.__UndoToken()\r
            return False\r
\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
                    % (self.Profile.FileLinesList[self.CurrentLineNumber - 1][self.CurrentOffsetWithinLine :], FileLineTuple[0], FileLineTuple[1], self.CurrentOffsetWithinLine)\r
            raise Warning("expected [Capsule.] At Line ", self.FileName, self.CurrentLineNumber)        \r
            \r
        CapsuleObj = CommonDataClass.FdfClass.CapsuleClassObject()\r
\r
        CapsuleName = self.__GetUiName()\r
        if not CapsuleName:\r
            raise Warning("expected capsule name At line ", self.FileName, self.CurrentLineNumber)\r
        \r
        CapsuleObj.UiCapsuleName = CapsuleName.upper()\r
        \r
        if not self.__IsToken( "]"):\r
            raise Warning("expected ']' At Line ", self.FileName, self.CurrentLineNumber)\r
        \r
        if self.__IsKeyword("CREATE_FILE"):\r
            if not self.__IsToken( "="):\r
                raise Warning("expected '=' At Line ", self.FileName, self.CurrentLineNumber)\r
            \r
            if not self.__GetNextToken():\r
                raise Warning("expected file name At Line ", self.FileName, self.CurrentLineNumber)\r
            \r
            CapsuleObj.CreateFile = self.__Token\r
        \r
        self.__GetCapsuleStatements(CapsuleObj)\r
        self.Profile.CapsuleList.append(CapsuleObj)\r
        return True    \r
            \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
    def __GetCapsuleStatements(self, Obj):\r
        self.__GetCapsuleTokens(Obj)\r
        self.__GetDefineStatements(Obj)\r
        self.__GetSetStatements(Obj)\r
        \r
        self.__GetCapsuleData(Obj)\r
                \r
    ## __GetCapsuleStatements() 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
    def __GetCapsuleTokens(self, Obj):\r
        \r
        if not self.__IsKeyword("CAPSULE_GUID"):\r
            raise Warning("expected 'CAPSULE_GUID' At Line ", self.FileName, self.CurrentLineNumber)\r
        \r
        while self.__CurrentLine().find("=") != -1:\r
            NameValue = self.__CurrentLine().split("=")\r
            Obj.TokensDict[NameValue[0].strip()] = NameValue[1].strip()\r
            self.CurrentLineNumber += 1\r
            self.CurrentOffsetWithinLine = 0\r
    \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
    def __GetCapsuleData(self, Obj):\r
        \r
        while True:\r
            IsInf = self.__GetInfStatement(Obj, True)\r
            IsFile = self.__GetFileStatement(Obj, True)\r
            IsFv = self.__GetFvStatement(Obj)\r
            if not IsInf and not IsFile and not IsFv:\r
                break\r
    \r
    ## __GetFvStatement() method\r
    #\r
    #   Get FV for capsule\r
    #\r
    #   @param  self        The object pointer\r
    #   @param  CapsuleObj  for whom FV is got\r
    #   @retval True        Successfully find a FV statement\r
    #   @retval False       Not able to find a FV statement\r
    #\r
    def __GetFvStatement(self, CapsuleObj):\r
        \r
        if not self.__IsKeyword("FV"):\r
            return False\r
        \r
        if not self.__IsToken("="):\r
            raise Warning("expected '=' At Line ", self.FileName, self.CurrentLineNumber)\r
        \r
        if not self.__GetNextToken():\r
            raise Warning("expected FV name At Line ", self.FileName, self.CurrentLineNumber)\r
        \r
#        CapsuleFv = CapsuleData.CapsuleFv()\r
#        CapsuleFv.FvName = self.__Token\r
#        CapsuleObj.CapsuleDataList.append(CapsuleFv)\r
        return True\r
    \r
    ## __GetRule() method\r
    #\r
    #   Get Rule section contents and store its data into rule list of self.Profile\r
    #\r
    #   @param  self        The object pointer\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
            return False\r
\r
        S = self.__Token.upper()\r
        if S.startswith("[") and not S.startswith("[RULE."):\r
            if not S.startswith("[OPTIONROM."):\r
                raise Warning("Unknown section or section appear sequence error (The correct sequence should be [FD.], [FV.], [Capsule.], [VTF.], [Rule.], [OptionRom.])", self.FileName, self.CurrentLineNumber)\r
            self.__UndoToken()\r
            return False\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
                    % (self.Profile.FileLinesList[self.CurrentLineNumber - 1][self.CurrentOffsetWithinLine :], FileLineTuple[0], FileLineTuple[1], self.CurrentOffsetWithinLine)\r
            raise Warning("expected [Rule.] At Line ", self.FileName, self.CurrentLineNumber)\r
\r
        if not self.__SkipToToken("."):\r
            raise Warning("expected '.' At Line ", self.FileName, self.CurrentLineNumber)\r
        \r
        Arch = self.__SkippedChars.rstrip(".")\r
        if Arch.upper() not in ("IA32", "X64", "IPF", "EBC", "ARM", "AARCH64", "COMMON"):\r
            raise Warning("Unknown Arch '%s'" % Arch, self.FileName, self.CurrentLineNumber)\r
        \r
        ModuleType = self.__GetModuleType()\r
        \r
        TemplateName = ""\r
        if self.__IsToken("."):\r
            if not self.__GetNextWord():\r
                raise Warning("expected template name At Line ", self.FileName, self.CurrentLineNumber)\r
            TemplateName = self.__Token\r
            \r
        if not self.__IsToken( "]"):\r
            raise Warning("expected ']' At Line ", self.FileName, self.CurrentLineNumber)\r
        \r
        RuleObj = self.__GetRuleFileStatements()\r
        RuleObj.Arch = Arch.upper()\r
        RuleObj.ModuleType = ModuleType\r
        RuleObj.TemplateName = TemplateName\r
        if TemplateName == '' :\r
            self.Profile.RuleDict['RULE'             + \\r
                              '.'                    + \\r
                              Arch.upper()           + \\r
                              '.'                    + \\r
                              ModuleType.upper()     ] = RuleObj\r
        else :\r
            self.Profile.RuleDict['RULE'             + \\r
                              '.'                    + \\r
                              Arch.upper()           + \\r
                              '.'                    + \\r
                              ModuleType.upper()     + \\r
                              '.'                    + \\r
                              TemplateName.upper() ] = RuleObj\r
#        self.Profile.RuleList.append(rule)\r
        return True\r
    \r
    ## __GetModuleType() method\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 At Line ", 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 At line ", 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
    def __GetFileExtension(self):\r
        if not self.__IsToken("."):\r
                raise Warning("expected '.' At Line ", self.FileName, self.CurrentLineNumber)\r
            \r
        Ext = ""\r
        if self.__GetNextToken():\r
            if FileExtensionPattern.match(self.__Token):\r
                Ext = self.__Token                            \r
                return '.' + Ext    \r
            else:\r
                raise Warning("Unknown file extension At Line ", self.FileName, self.CurrentLineNumber)\r
                \r
        else:\r
            raise Warning("expected file extension At Line ", self.FileName, self.CurrentLineNumber)\r
        \r
    ## __GetRuleFileStatement() method\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 At Line ", self.FileName, self.CurrentLineNumber)\r
        \r
        if not self.__GetNextWord():\r
            raise Warning("expected FFS type At Line ", 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"):\r
            raise Warning("Unknown FV type At line ", self.FileName, self.CurrentLineNumber)\r
\r
        if not self.__IsToken("="):\r
            raise Warning("expected '=' At Line ", self.FileName, self.CurrentLineNumber)\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
\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
                    KeepReloc = False\r
                else:\r
                    KeepReloc = True\r
            else:\r
                raise Warning("File type %s could not have reloc strip flag At Line %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\" At Line ", self.FileName, self.CurrentLineNumber)\r
                        KeyStringList.append(self.__Token)\r
\r
                        if not self.__IsToken(","):\r
                            break\r
                    \r
            else:\r
                self.__UndoToken()\r
\r
        \r
        Fixed = False\r
        if self.__IsKeyword("Fixed", True):\r
            Fixed = True\r
            \r
        CheckSum = False\r
        if self.__IsKeyword("CheckSum", True):\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 At Line ", self.FileName, self.CurrentLineNumber)\r
            AlignValue = self.__Token\r
\r
        if self.__IsToken("{"):\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
            if KeepReloc is not None:\r
                Rule.KeepReloc = KeepReloc\r
            \r
            while True:\r
                IsEncapsulate = self.__GetRuleEncapsulationSection(Rule)\r
                IsLeaf = self.__GetEfiSection(Rule)\r
                if not IsEncapsulate and not IsLeaf:\r
                    break\r
                \r
            if not self.__IsToken("}"):\r
                raise Warning("expected '}' At Line ", self.FileName, self.CurrentLineNumber)\r
            \r
            return Rule\r
        \r
        elif self.__IsToken("|"):\r
            # Ext rule expected\r
            Ext = self.__GetFileExtension()\r
            \r
            Rule = RuleSimpleFile.RuleSimpleFile()\r
\r
            Rule.FvFileType = Type\r
            Rule.NameGuid = NameGuid\r
            Rule.Alignment = AlignValue\r
            Rule.CheckSum = CheckSum\r
            Rule.Fixed = Fixed\r
            Rule.FileExtension = Ext\r
            Rule.KeyStringList = KeyStringList\r
            if KeepReloc is not None:\r
                Rule.KeepReloc = KeepReloc\r
            \r
            return Rule\r
            \r
        else:\r
            # Simple file rule expected\r
            if not self.__GetNextWord():\r
                raise Warning("expected leaf section type At Line ", self.FileName, self.CurrentLineNumber)\r
\r
            SectionName = self.__Token\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
                raise Warning("Unknown leaf section name '%s'" % SectionName, self.FileName, self.CurrentLineNumber)\r
\r
\r
            if self.__IsKeyword("Fixed", True):\r
                Fixed = True              \r
    \r
            if self.__IsKeyword("CheckSum", True):\r
                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 At Line ", self.FileName, self.CurrentLineNumber)\r
                if self.__Token == 'Auto' and (not SectionName == 'PE32') and (not SectionName == 'TE'):\r
                    raise Warning("Auto alignment can only be used in PE32 or TE section ", self.FileName, self.CurrentLineNumber)\r
                AlignValue = self.__Token\r
            \r
            if not self.__GetNextToken():\r
                raise Warning("expected File name At Line ", 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.CheckSum = CheckSum\r
            Rule.Fixed = Fixed\r
            Rule.FileName = self.__Token\r
            Rule.KeyStringList = KeyStringList\r
            if KeepReloc is not None:\r
                Rule.KeepReloc = KeepReloc\r
            return Rule\r
        \r
    ## __GetEfiSection() method\r
    #\r
    #   Get section list for Rule\r
    #\r
    #   @param  self        The object pointer\r
    #   @param  Obj         for whom section is got\r
    #   @retval True        Successfully find section statement\r
    #   @retval False       Not able to find section statement\r
    #\r
    def __GetEfiSection(self, Obj):\r
        \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
            return False\r
        \r
        if SectionName == "FV_IMAGE":\r
            FvImageSectionObj = FvImageSection.FvImageSection()\r
            if self.__IsKeyword("FV_IMAGE"):\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
    \r
                while True:\r
                    IsInf = self.__GetInfStatement(FvObj)\r
                    IsFile = self.__GetFileStatement(FvObj)\r
                    if not IsInf and not IsFile:\r
                        break\r
    \r
                if not self.__IsToken( "}"):\r
                    raise Warning("expected '}' At Line ", self.FileName, self.CurrentLineNumber)\r
                FvImageSectionObj.Fv = FvObj\r
                FvImageSectionObj.FvName = None\r
                \r
            else:\r
                if not self.__IsKeyword("FV"):\r
                    raise Warning("expected 'FV' At Line ", 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 At Line ", 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
                    else:\r
                        self.__UndoToken()\r
                else:\r
                    raise Warning("expected FV file name At Line ", self.FileName, self.CurrentLineNumber)\r
                    \r
            Obj.SectionList.append(FvImageSectionObj)\r
            return True\r
        \r
        EfiSectionObj = EfiSection.EfiSection()\r
        EfiSectionObj.SectionType = SectionName\r
        \r
        if not self.__GetNextToken():\r
            raise Warning("expected file type At Line ", self.FileName, self.CurrentLineNumber)\r
        \r
        if self.__Token == "STRING":\r
            if not self.__RuleSectionCouldHaveString(EfiSectionObj.SectionType):\r
                raise Warning("%s section could NOT have string data At Line %d" % (EfiSectionObj.SectionType, self.CurrentLineNumber), self.FileName, self.CurrentLineNumber)\r
            \r
            if not self.__IsToken('='):\r
                raise Warning("expected '=' At Line ", self.FileName, self.CurrentLineNumber)\r
            \r
            if not self.__GetNextToken():\r
                raise Warning("expected Quoted String At Line ", self.FileName, self.CurrentLineNumber)\r
        \r
            if self.__GetStringData():\r
                EfiSectionObj.StringData = self.__Token\r
            \r
            if self.__IsKeyword("BUILD_NUM"):\r
                if not self.__RuleSectionCouldHaveBuildNum(EfiSectionObj.SectionType):\r
                    raise Warning("%s section could NOT have BUILD_NUM At Line %d" % (EfiSectionObj.SectionType, self.CurrentLineNumber), self.FileName, self.CurrentLineNumber)\r
            \r
                if not self.__IsToken("="):\r
                    raise Warning("expected '=' At Line ", self.FileName, self.CurrentLineNumber)\r
                if not self.__GetNextToken():\r
                    raise Warning("expected Build number At Line ", self.FileName, self.CurrentLineNumber)\r
                EfiSectionObj.BuildNum = self.__Token\r
                \r
        else:\r
            EfiSectionObj.FileType = self.__Token\r
            self.__CheckRuleSectionFileType(EfiSectionObj.SectionType, EfiSectionObj.FileType)\r
            \r
        if self.__IsKeyword("Optional"):\r
            if not self.__RuleSectionCouldBeOptional(EfiSectionObj.SectionType):\r
                raise Warning("%s section could NOT be optional At Line %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
                    raise Warning("%s section could NOT have BUILD_NUM At Line %d" % (EfiSectionObj.SectionType, self.CurrentLineNumber), self.FileName, self.CurrentLineNumber)\r
                \r
                if not self.__IsToken("="):\r
                    raise Warning("expected '=' At Line ", self.FileName, self.CurrentLineNumber)\r
                if not self.__GetNextToken():\r
                    raise Warning("expected Build number At Line ", 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
                raise Warning("Auto alignment can only be used in PE32 or TE section ", self.FileName, self.CurrentLineNumber)\r
            EfiSectionObj.Alignment = self.__Token\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
                    EfiSectionObj.KeepReloc = False\r
                else:\r
                    EfiSectionObj.KeepReloc = True\r
                if Obj.KeepReloc is not None and Obj.KeepReloc != EfiSectionObj.KeepReloc:\r
                    raise Warning("Section type %s has reloc strip flag conflict with Rule At Line %d" % (EfiSectionObj.SectionType, self.CurrentLineNumber), self.FileName, self.CurrentLineNumber)\r
            else:\r
                raise Warning("Section type %s could not have reloc strip flag At Line %d" % (EfiSectionObj.SectionType, self.CurrentLineNumber), 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
            else:\r
                self.__UndoToken()\r
        else:\r
            raise Warning("expected section file name At Line ", self.FileName, self.CurrentLineNumber)\r
                \r
        Obj.SectionList.append(EfiSectionObj)\r
        return True\r
        \r
    ## __RuleSectionCouldBeOptional() method\r
    #\r
    #   Get whether a section could be optional\r
    #\r
    #   @param  self        The object pointer\r
    #   @param  SectionType The section type to check\r
    #   @retval True        section could be optional\r
    #   @retval False       section never optional\r
    #\r
    def __RuleSectionCouldBeOptional(self, SectionType):\r
        if SectionType in ("DXE_DEPEX", "UI", "VERSION", "PEI_DEPEX", "RAW", "SMM_DEPEX"):\r
            return True\r
        else:\r
            return False\r
    \r
    ## __RuleSectionCouldHaveBuildNum() method\r
    #\r
    #   Get whether a section could have build number information\r
    #\r
    #   @param  self        The object pointer\r
    #   @param  SectionType The section type to check\r
    #   @retval True        section could have build number information\r
    #   @retval False       section never have build number information\r
    #\r
    def __RuleSectionCouldHaveBuildNum(self, SectionType):\r
        if SectionType in ("VERSION"):\r
            return True\r
        else:\r
            return False\r
    \r
    ## __RuleSectionCouldHaveString() method\r
    #\r
    #   Get whether a section could have string\r
    #\r
    #   @param  self        The object pointer\r
    #   @param  SectionType The section type to check\r
    #   @retval True        section could have string\r
    #   @retval False       section never have string\r
    #\r
    def __RuleSectionCouldHaveString(self, SectionType):\r
        if SectionType in ("UI", "VERSION"):\r
            return True\r
        else:\r
            return False\r
    \r
    ## __CheckRuleSectionFileType() method\r
    #\r
    #   Get whether a section matches a file type\r
    #\r
    #   @param  self        The object pointer\r
    #   @param  SectionType The section type to check\r
    #   @param  FileType    The file type to check\r
    #\r
    def __CheckRuleSectionFileType(self, SectionType, FileType):\r
        if SectionType == "COMPAT16":\r
            if FileType not in ("COMPAT16", "SEC_COMPAT16"):\r
                raise Warning("Incorrect section file type At Line ", self.FileName, self.CurrentLineNumber)\r
        elif SectionType == "PE32":\r
            if FileType not in ("PE32", "SEC_PE32"):\r
                raise Warning("Incorrect section file type At Line ", self.FileName, self.CurrentLineNumber)\r
        elif SectionType == "PIC":\r
            if FileType not in ("PIC", "PIC"):\r
                raise Warning("Incorrect section file type At Line ", self.FileName, self.CurrentLineNumber)\r
        elif SectionType == "TE":\r
            if FileType not in ("TE", "SEC_TE"):\r
                raise Warning("Incorrect section file type At Line ", self.FileName, self.CurrentLineNumber)\r
        elif SectionType == "RAW":\r
            if FileType not in ("BIN", "SEC_BIN", "RAW", "ASL", "ACPI"):\r
                raise Warning("Incorrect section file type At Line ", 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 At Line ", self.FileName, self.CurrentLineNumber)\r
        elif SectionType == "UI":\r
            if FileType not in ("UI", "SEC_UI"):\r
                raise Warning("Incorrect section file type At Line ", self.FileName, self.CurrentLineNumber)\r
        elif SectionType == "VERSION":\r
            if FileType not in ("VERSION", "SEC_VERSION"):\r
                raise Warning("Incorrect section file type At Line ", 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 At Line ", self.FileName, self.CurrentLineNumber)\r
        elif SectionType == "GUID":\r
            if FileType not in ("PE32", "SEC_GUID"):\r
                raise Warning("Incorrect section file type At Line ", self.FileName, self.CurrentLineNumber)    \r
              \r
    ## __GetRuleEncapsulationSection() method\r
    #\r
    #   Get encapsulation section for Rule\r
    #\r
    #   @param  self        The object pointer\r
    #   @param  Rule        for whom section is got\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
            Type = "PI_STD"\r
            if self.__IsKeyword("PI_STD") or self.__IsKeyword("PI_NONE"):\r
                Type = self.__Token\r
                \r
            if not self.__IsToken("{"):\r
                raise Warning("expected '{' At Line ", self.FileName, self.CurrentLineNumber)\r
\r
            CompressSectionObj = CompressSection.CompressSection()\r
            \r
            CompressSectionObj.CompType = Type\r
            # Recursive sections...\r
            while True:\r
                IsEncapsulate = self.__GetRuleEncapsulationSection(CompressSectionObj)\r
                IsLeaf = self.__GetEfiSection(CompressSectionObj)\r
                if not IsEncapsulate and not IsLeaf:\r
                    break\r
            \r
            if not self.__IsToken( "}"):\r
                raise Warning("expected '}' At Line ", self.FileName, self.CurrentLineNumber)\r
            Rule.SectionList.append(CompressSectionObj)\r
                \r
            return True\r
\r
        elif self.__IsKeyword( "GUIDED"):\r
            GuidValue = None\r
            if self.__GetNextGuid():\r
                GuidValue = self.__Token\r
            \r
            if self.__IsKeyword( "$(NAMED_GUID)"):\r
                GuidValue = self.__Token\r
                \r
            AttribDict = self.__GetGuidAttrib()\r
            \r
            if not self.__IsToken("{"):\r
                raise Warning("expected '{' At Line ", self.FileName, self.CurrentLineNumber)\r
            GuidSectionObj = GuidSection.GuidSection()\r
            GuidSectionObj.NameGuid = GuidValue\r
            GuidSectionObj.SectionType = "GUIDED"\r
            GuidSectionObj.ProcessRequired = AttribDict["PROCESSING_REQUIRED"]\r
            GuidSectionObj.AuthStatusValid = AttribDict["AUTH_STATUS_VALID"]\r
            \r
            # Efi sections...\r
            while True:\r
                IsEncapsulate = self.__GetRuleEncapsulationSection(GuidSectionObj)\r
                IsLeaf = self.__GetEfiSection(GuidSectionObj)\r
                if not IsEncapsulate and not IsLeaf:\r
                    break\r
            \r
            if not self.__IsToken( "}"):\r
                raise Warning("expected '}' At Line ", self.FileName, self.CurrentLineNumber)\r
            Rule.SectionList.append(GuidSectionObj)\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
            if not S.startswith("[RULE.") and not S.startswith("[OPTIONROM."):\r
                raise Warning("Unknown section or section appear sequence error (The correct sequence should be [FD.], [FV.], [Capsule.], [VTF.], [Rule.], [OptionRom.])", self.FileName, self.CurrentLineNumber)\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.] At Line ", self.FileName, self.CurrentLineNumber)\r
\r
        if not self.__SkipToToken("."):\r
            raise Warning("expected '.' At Line ", 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 At line ", self.FileName, self.CurrentLineNumber)\r
\r
        if not self.__GetNextWord():\r
            raise Warning("expected VTF name At Line ", 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 At Line ", self.FileName, self.CurrentLineNumber)\r
            if self.__Token.upper() not in ("IA32", "X64", "IPF", "ARM", "AARCH64"):\r
                raise Warning("Unknown Arch At line ", self.FileName, self.CurrentLineNumber)\r
            VtfObj.ArchList = self.__Token.upper()\r
\r
        if not self.__IsToken( "]"):\r
            raise Warning("expected ']' At Line ", self.FileName, self.CurrentLineNumber)\r
        \r
        if self.__IsKeyword("IA32_RST_BIN"):\r
            if not self.__IsToken("="):\r
                raise Warning("expected '=' At Line ", self.FileName, self.CurrentLineNumber)\r
\r
            if not self.__GetNextToken():\r
                raise Warning("expected Reset file At Line ", self.FileName, self.CurrentLineNumber)\r
\r
            VtfObj.ResetBin = self.__Token\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 '=' At Line ", self.FileName, self.CurrentLineNumber)\r
\r
        if not self.__GetNextWord():\r
            raise Warning("expected Component Name At Line ", 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 At Line ", self.FileName, self.CurrentLineNumber)\r
\r
        if not self.__IsToken("="):\r
            raise Warning("expected '=' At Line ", 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 At Line ", 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 At line ", 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 At Line ", self.FileName, self.CurrentLineNumber)\r
\r
        if not self.__IsToken("="):\r
            raise Warning("expected '=' At Line ", self.FileName, self.CurrentLineNumber)\r
\r
        if not self.__GetNextToken():\r
            raise Warning("expected Component type At Line ", 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 At line ", self.FileName, self.CurrentLineNumber)\r
        CompStatementObj.CompType = self.__Token\r
        \r
        if not self.__IsKeyword("COMP_VER"):\r
            raise Warning("expected COMP_VER At Line ", self.FileName, self.CurrentLineNumber)\r
\r
        if not self.__IsToken("="):\r
            raise Warning("expected '=' At Line ", self.FileName, self.CurrentLineNumber)\r
\r
        if not self.__GetNextToken():\r
            raise Warning("expected Component version At Line ", self.FileName, self.CurrentLineNumber)\r
\r
        Pattern = re.compile('-$|[0-9]{0,1}[0-9]{1}\.[0-9]{0,1}[0-9]{1}')\r
        if Pattern.match(self.__Token) is None:\r
            raise Warning("Unknown version format At line ", self.FileName, self.CurrentLineNumber)\r
        CompStatementObj.CompVer = self.__Token\r
        \r
        if not self.__IsKeyword("COMP_CS"):\r
            raise Warning("expected COMP_CS At Line ", self.FileName, self.CurrentLineNumber)\r
\r
        if not self.__IsToken("="):\r
            raise Warning("expected '=' At Line ", self.FileName, self.CurrentLineNumber)\r
\r
        if not self.__GetNextToken():\r
            raise Warning("expected Component CS At Line ", self.FileName, self.CurrentLineNumber)\r
        if self.__Token not in ("1", "0"):\r
            raise Warning("Unknown  Component CS At line ", self.FileName, self.CurrentLineNumber)\r
        CompStatementObj.CompCs = self.__Token\r
        \r
        \r
        if not self.__IsKeyword("COMP_BIN"):\r
            raise Warning("expected COMP_BIN At Line ", self.FileName, self.CurrentLineNumber)\r
\r
        if not self.__IsToken("="):\r
            raise Warning("expected '=' At Line ", self.FileName, self.CurrentLineNumber)\r
\r
        if not self.__GetNextToken():\r
            raise Warning("expected Component file At Line ", self.FileName, self.CurrentLineNumber)\r
\r
        CompStatementObj.CompBin = self.__Token\r
        \r
        if not self.__IsKeyword("COMP_SYM"):\r
            raise Warning("expected COMP_SYM At Line ", self.FileName, self.CurrentLineNumber)\r
\r
        if not self.__IsToken("="):\r
            raise Warning("expected '=' At Line ", self.FileName, self.CurrentLineNumber)\r
\r
        if not self.__GetNextToken():\r
            raise Warning("expected Component symbol file At Line ", self.FileName, self.CurrentLineNumber)\r
\r
        CompStatementObj.CompSym = self.__Token\r
    \r
        if not self.__IsKeyword("COMP_SIZE"):\r
            raise Warning("expected COMP_SIZE At Line ", self.FileName, self.CurrentLineNumber)\r
\r
        if not self.__IsToken("="):\r
            raise Warning("expected '=' At Line ", 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 At line ", self.FileName, self.CurrentLineNumber)\r
        \r
        VtfObj.ComponentStatementList.append(CompStatementObj)\r
        return True\r
    \r
    ## __GetFvInFd() method\r
    #\r
    #   Get FV list contained in FD\r
    #\r
    #   @param  self        The object pointer\r
    #   @param  FdName      FD name\r
    #   @retval FvList      list of FV in FD\r
    #\r
    def __GetFvInFd (self, FdName):\r
    \r
        FvList = []\r
        if FdName.upper() in self.Profile.FdDict.keys():\r
            FdObj = self.Profile.FdDict[FdName.upper()]\r
            for elementRegion in FdObj.RegionList:\r
                if elementRegion.RegionType == 'FV':\r
                    for elementRegionData in elementRegion.RegionDataList:\r
                        if elementRegionData is not None and elementRegionData.upper() not in FvList:\r
                            FvList.append(elementRegionData.upper())\r
        return FvList\r
    \r
    ## __GetReferencedFdFvTuple() method\r
    #\r
    #   Get FD and FV list referenced by a FFS file\r
    #\r
    #   @param  self        The object pointer\r
    #   @param  FfsFile     contains sections to be searched\r
    #   @param  RefFdList   referenced FD by section\r
    #   @param  RefFvList   referenced FV by section\r
    #\r
    def __GetReferencedFdFvTuple(self, FvObj, RefFdList = [], RefFvList = []):\r
        \r
        for FfsObj in FvObj.FfsList:\r
            if isinstance(FfsObj, FfsFileStatement.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
                    self.__GetReferencedFdFvTupleFromSection(FfsObj, RefFdList, RefFvList)    \r
    \r
    ## __GetReferencedFdFvTupleFromSection() method\r
    #\r
    #   Get FD and FV list referenced by a FFS section\r
    #\r
    #   @param  self        The object pointer\r
    #   @param  FfsFile     contains sections to be searched\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
        while SectionStack != []:\r
            SectionObj = SectionStack.pop()\r
            if isinstance(SectionObj, FvImageSection.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
                    self.__GetReferencedFdFvTuple(SectionObj.Fv, FdList, FvList)\r
            \r
            if isinstance(SectionObj, CompressSection.CompressSection) or isinstance(SectionObj, GuidSection.GuidSection):\r
                SectionStack.extend(SectionObj.SectionList)\r
                          \r
    ## CycleReferenceCheck() method\r
    #\r
    #   Check whether cycle reference exists in FDF\r
    #\r
    #   @param  self        The object pointer\r
    #   @retval True        cycle reference exists\r
    #   @retval False       Not exists cycle reference\r
    #\r
    def CycleReferenceCheck(self):\r
        \r
        CycleRefExists = False\r
        \r
        try:\r
            for FvName in self.Profile.FvDict.keys():\r
                LogStr = "Cycle Reference Checking for FV: %s\n" % FvName\r
                RefFvStack = []\r
                RefFvStack.append(FvName)\r
                FdAnalyzedList = []\r
                \r
                while RefFvStack != []:\r
                    FvNameFromStack = RefFvStack.pop()\r
                    if FvNameFromStack.upper() in self.Profile.FvDict.keys():\r
                        FvObj = self.Profile.FvDict[FvNameFromStack.upper()]\r
                    else:\r
                        continue\r
                    \r
                    RefFdList = []\r
                    RefFvList = []\r
                    self.__GetReferencedFdFvTuple(FvObj, RefFdList, RefFvList)\r
                    \r
                    for RefFdName in RefFdList:\r
                        if RefFdName in FdAnalyzedList:\r
                            continue\r
                        \r
                        LogStr += "FD %s is referenced by FV %s\n" % (RefFdName, FvNameFromStack) \r
                        FvInFdList = self.__GetFvInFd(RefFdName)\r
                        if FvInFdList != []:\r
                            LogStr += "FD %s contains FV: " % RefFdName\r
                            for FvObj in FvInFdList:\r
                                LogStr += FvObj\r
                                LogStr += ' \n'\r
                                if FvObj not in RefFvStack:\r
                                    RefFvStack.append(FvObj)\r
                        \r
                                if FvName in RefFvStack:\r
                                    CycleRefExists = True\r
                                    raise Warning(LogStr)\r
                        FdAnalyzedList.append(RefFdName)\r
                                   \r
                    for RefFvName in RefFvList:\r
                        LogStr += "FV %s is referenced by FV %s\n" % (RefFvName, FvNameFromStack)\r
                        if RefFvName not in RefFvStack:\r
                            RefFvStack.append(RefFvName)\r
                            \r
                        if FvName in RefFvStack:\r
                            CycleRefExists = True\r
                            raise Warning(LogStr)\r
        \r
        except Warning:\r
            print LogStr\r
        \r
        finally:\r
            return CycleRefExists\r
        \r
if __name__ == "__main__":\r
    import sys\r
    try:\r
        test_file = sys.argv[1]\r
    except IndexError, 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
    except Warning, X:\r
        print X.message\r
    else:\r
        print "Success!"\r
\r